diff --git a/compiled/facebook-www/REVISION b/compiled/facebook-www/REVISION
index ee73d4c05aa95..a55b7b1397de3 100644
--- a/compiled/facebook-www/REVISION
+++ b/compiled/facebook-www/REVISION
@@ -1 +1 @@
-2788d0d8dd95ed57e2dbb148853fe69010e992fe
+6bd53a5bdfe24d9a70819c4eba40b488e62900cd
diff --git a/compiled/facebook-www/React-dev.modern.js b/compiled/facebook-www/React-dev.modern.js
index 3ca572e53db01..2065ca9edcaea 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-f236d170";
+var ReactVersion = "18.3.0-www-modern-724bb919";
 
 // 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 3767cfd623f49..6413b726a89d1 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-dd1bbdc2";
+var ReactVersion = "18.3.0-www-classic-5ea6b0b1";
 
 var LegacyRoot = 0;
 var ConcurrentRoot = 1;
diff --git a/compiled/facebook-www/ReactDOMTesting-dev.classic.js b/compiled/facebook-www/ReactDOMTesting-dev.classic.js
index da7f7d4e959cb..8f2654e8ed9d7 100644
--- a/compiled/facebook-www/ReactDOMTesting-dev.classic.js
+++ b/compiled/facebook-www/ReactDOMTesting-dev.classic.js
@@ -21,22 +21,58 @@ var React = require("react");
 
 var assign = Object.assign;
 
-var debugRenderPhaseSideEffectsForStrictMode = false;
-var enableSchedulingProfiler = false;
-var enableProfilerTimer = false;
-var disableCommentsAsDOMContainers = true;
-var enableSuspenseCallback = true;
-var enableClientRenderFallbackOnTextMismatch = true;
+// Re-export dynamic flags from the www version.
+var dynamicFeatureFlags = require("ReactFeatureFlags");
+
+var disableInputAttributeSyncing =
+    dynamicFeatureFlags.disableInputAttributeSyncing,
+  enableTrustedTypesIntegration =
+    dynamicFeatureFlags.enableTrustedTypesIntegration,
+  replayFailedUnitOfWorkWithInvokeGuardedCallback =
+    dynamicFeatureFlags.replayFailedUnitOfWorkWithInvokeGuardedCallback,
+  enableFilterEmptyStringAttributesDOM =
+    dynamicFeatureFlags.enableFilterEmptyStringAttributesDOM,
+  enableLegacyFBSupport = dynamicFeatureFlags.enableLegacyFBSupport,
+  deferRenderPhaseUpdateToNextBatch =
+    dynamicFeatureFlags.deferRenderPhaseUpdateToNextBatch,
+  enableDebugTracing = dynamicFeatureFlags.enableDebugTracing,
+  skipUnmountedBoundaries = dynamicFeatureFlags.skipUnmountedBoundaries,
+  enableUseRefAccessWarning = dynamicFeatureFlags.enableUseRefAccessWarning,
+  disableNativeComponentFrames =
+    dynamicFeatureFlags.disableNativeComponentFrames,
+  disableSchedulerTimeoutInWorkLoop =
+    dynamicFeatureFlags.disableSchedulerTimeoutInWorkLoop,
+  enableLazyContextPropagation =
+    dynamicFeatureFlags.enableLazyContextPropagation,
+  enableUnifiedSyncLane = dynamicFeatureFlags.enableUnifiedSyncLane,
+  enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay =
+    dynamicFeatureFlags.enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay,
+  enableTransitionTracing = dynamicFeatureFlags.enableTransitionTracing,
+  enableCustomElementPropertySupport =
+    dynamicFeatureFlags.enableCustomElementPropertySupport; // On WWW, false is used for a new modern build.
+var enableProfilerTimer = true;
+var enableProfilerCommitHooks = true;
+var enableProfilerNestedUpdatePhase = true;
+var enableProfilerNestedUpdateScheduledHook =
+  dynamicFeatureFlags.enableProfilerNestedUpdateScheduledHook;
 var createRootStrictEffectsByDefault = false;
-var enableLazyContextPropagation = false;
-var enableLegacyHidden = false;
-var enableCustomElementPropertySupport = false;
+var enableClientRenderFallbackOnTextMismatch = false; // Logs additional User Timing API marks for use with an experimental profiling tool.
+
+var enableSchedulingProfiler = dynamicFeatureFlags.enableSchedulingProfiler; // Note: we'll want to remove this when we to userland implementation.
+var enableSuspenseCallback = true;
 
 // This refers to a WWW module.
 var warningWWW = require("warning");
+
+var suppressWarning = false;
+function setSuppressWarning(newSuppressWarning) {
+  {
+    suppressWarning = newSuppressWarning;
+  }
+}
 function warn(format) {
   {
-    {
+    if (!suppressWarning) {
       for (
         var _len = arguments.length,
           args = new Array(_len > 1 ? _len - 1 : 0),
@@ -53,7 +89,7 @@ function warn(format) {
 }
 function error(format) {
   {
-    {
+    if (!suppressWarning) {
       for (
         var _len2 = arguments.length,
           args = new Array(_len2 > 1 ? _len2 - 1 : 0),
@@ -171,6 +207,7 @@ var REACT_TRACING_MARKER_TYPE = Symbol.for("react.tracing_marker");
 var REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for(
   "react.default_value"
 );
+var REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel");
 var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
 var FAUX_ITERATOR_SYMBOL = "@@iterator";
 function getIteratorFn(maybeIterable) {
@@ -251,6 +288,13 @@ function getComponentNameFromType(type) {
     case REACT_CACHE_TYPE: {
       return "Cache";
     }
+
+    // eslint-disable-next-line no-fallthrough
+
+    case REACT_TRACING_MARKER_TYPE:
+      if (enableTransitionTracing) {
+        return "TracingMarker";
+      }
   }
 
   if (typeof type === "object") {
@@ -397,6 +441,10 @@ function getComponentNameFromFiber(fiber) {
       }
 
       break;
+
+    case LegacyHiddenComponent: {
+      return "LegacyHidden";
+    }
   }
 
   return null;
@@ -470,6 +518,12 @@ var ShouldCapture =
 var ForceUpdateForLegacySuspense =
   /* */
   131072;
+var DidPropagateContext =
+  /*          */
+  262144;
+var NeedsPropagation =
+  /*             */
+  524288;
 var Forked =
   /*                       */
   1048576; // Static tags describe aspects of a fiber that are not specific to a render,
@@ -1436,10 +1490,43 @@ function shouldRemoveAttribute(
   }
 
   if (isCustomComponentTag) {
+    if (enableCustomElementPropertySupport) {
+      if (value === false) {
+        return true;
+      }
+    }
+
     return false;
   }
 
   if (propertyInfo !== null) {
+    if (enableFilterEmptyStringAttributesDOM) {
+      if (propertyInfo.removeEmptyString && value === "") {
+        {
+          if (name === "src") {
+            error(
+              'An empty string ("") was passed to the %s attribute. ' +
+                "This may cause the browser to download the whole page again over the network. " +
+                "To fix this, either do not render the element at all " +
+                "or pass null to %s instead of an empty string.",
+              name,
+              name
+            );
+          } else {
+            error(
+              'An empty string ("") was passed to the %s attribute. ' +
+                "To fix this, either do not render the element at all " +
+                "or pass null to %s instead of an empty string.",
+              name,
+              name
+            );
+          }
+        }
+
+        return true;
+      }
+    }
+
     switch (propertyInfo.type) {
       case BOOLEAN:
         return !value;
@@ -1500,6 +1587,10 @@ var reservedProps = [
   "style"
 ];
 
+if (enableCustomElementPropertySupport) {
+  reservedProps.push("innerText", "textContent");
+}
+
 reservedProps.forEach(function (name) {
   // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
   properties[name] = new PropertyInfoRecord(
@@ -1988,6 +2079,12 @@ function getValueForAttribute(node, name, expected, isCustomComponentTag) {
 
     var value = node.getAttribute(name);
 
+    if (enableCustomElementPropertySupport) {
+      if (isCustomComponentTag && value === "") {
+        return true;
+      }
+    }
+
     {
       checkAttributeStringCoercion(expected, name);
     }
@@ -2014,10 +2111,57 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
     return;
   }
 
+  if (
+    enableCustomElementPropertySupport &&
+    isCustomComponentTag &&
+    name[0] === "o" &&
+    name[1] === "n"
+  ) {
+    var eventName = name.replace(/Capture$/, "");
+    var useCapture = name !== eventName;
+    eventName = eventName.slice(2);
+    var prevProps = getFiberCurrentPropsFromNode(node);
+    var prevValue = prevProps != null ? prevProps[name] : null;
+
+    if (typeof prevValue === "function") {
+      node.removeEventListener(eventName, prevValue, useCapture);
+    }
+
+    if (typeof value === "function") {
+      if (typeof prevValue !== "function" && prevValue !== null) {
+        // If we previously assigned a non-function type into this node, then
+        // remove it when switching to event listener mode.
+        if (name in node) {
+          node[name] = null;
+        } else if (node.hasAttribute(name)) {
+          node.removeAttribute(name);
+        }
+      } // $FlowFixMe value can't be casted to EventListener.
+
+      node.addEventListener(eventName, value, useCapture);
+      return;
+    }
+  }
+
+  if (
+    enableCustomElementPropertySupport &&
+    isCustomComponentTag &&
+    name in node
+  ) {
+    node[name] = value;
+    return;
+  }
+
   if (shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag)) {
     value = null;
   }
 
+  if (enableCustomElementPropertySupport) {
+    if (isCustomComponentTag && value === true) {
+      value = "";
+    }
+  } // If the prop isn't in the special list, treat it as a simple attribute.
+
   if (isCustomComponentTag || propertyInfo === null) {
     if (isAttributeNameSafe(name)) {
       var _attributeName = name;
@@ -2029,7 +2173,10 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
           checkAttributeStringCoercion(value, name);
         }
 
-        node.setAttribute(_attributeName, "" + value);
+        node.setAttribute(
+          _attributeName,
+          enableTrustedTypesIntegration ? value : "" + value
+        );
       }
     }
 
@@ -2069,7 +2216,9 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
     } else {
       // `setAttribute` with objects becomes only `[object]` in IE8/9,
       // ('' + value) makes it output the correct toString()-value.
-      {
+      if (enableTrustedTypesIntegration) {
+        attributeValue = value;
+      } else {
         {
           checkAttributeStringCoercion(value, attributeName);
         }
@@ -2208,13 +2357,13 @@ var reentry = false;
 var componentFrameCache;
 
 {
-  var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map;
-  componentFrameCache = new PossiblyWeakMap$1();
+  var PossiblyWeakMap$2 = typeof WeakMap === "function" ? WeakMap : Map;
+  componentFrameCache = new PossiblyWeakMap$2();
 }
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
-  if (!fn || reentry) {
+  if (disableNativeComponentFrames || !fn || reentry) {
     return "";
   }
 
@@ -2929,7 +3078,14 @@ function updateWrapper$1(element, props) {
     return;
   }
 
-  {
+  if (disableInputAttributeSyncing) {
+    // When not syncing the value attribute, React only assigns a new value
+    // whenever the defaultValue React prop has changed. When not present,
+    // React does nothing
+    if (props.hasOwnProperty("defaultValue")) {
+      setDefaultValue(node, props.type, getToStringValue(props.defaultValue));
+    }
+  } else {
     // When syncing the value attribute, the value comes from a cascade of
     // properties:
     //  1. The value React property
@@ -2942,7 +3098,16 @@ function updateWrapper$1(element, props) {
     }
   }
 
-  {
+  if (disableInputAttributeSyncing) {
+    // When not syncing the checked attribute, the attribute is directly
+    // controllable from the defaultValue React property. It needs to be
+    // updated as new props come in.
+    if (props.defaultChecked == null) {
+      node.removeAttribute("checked");
+    } else {
+      node.defaultChecked = !!props.defaultChecked;
+    }
+  } else {
     // When syncing the checked attribute, it only changes when it needs
     // to be removed, such as transitioning from a checkbox into a text input
     if (props.checked == null && props.defaultChecked != null) {
@@ -2967,7 +3132,24 @@ function postMountWrapper$3(element, props, isHydrating) {
     // from being lost during SSR hydration.
 
     if (!isHydrating) {
-      {
+      if (disableInputAttributeSyncing) {
+        var value = getToStringValue(props.value); // When not syncing the value attribute, the value property points
+        // directly to the React prop. Only assign it if it exists.
+
+        if (value != null) {
+          // Always assign on buttons so that it is possible to assign an
+          // empty string to clear button text.
+          //
+          // Otherwise, do not re-assign the value property if is empty. This
+          // potentially avoids a DOM write and prevents Firefox (~60.0.1) from
+          // prematurely marking required inputs as invalid. Equality is compared
+          // to the current value in case the browser provided value is not an
+          // empty string.
+          if (isButton || value !== node.value) {
+            node.value = toString(value);
+          }
+        }
+      } else {
         // When syncing the value attribute, the value property should use
         // the wrapperState._initialValue property. This uses:
         //
@@ -2980,7 +3162,15 @@ function postMountWrapper$3(element, props, isHydrating) {
       }
     }
 
-    {
+    if (disableInputAttributeSyncing) {
+      // When not syncing the value attribute, assign the value attribute
+      // directly from the defaultValue React property (when present)
+      var defaultValue = getToStringValue(props.defaultValue);
+
+      if (defaultValue != null) {
+        node.defaultValue = toString(defaultValue);
+      }
+    } else {
       // Otherwise, the value attribute is synchronized to the property,
       // so we assign defaultValue to the same thing as the value property
       // assignment step above.
@@ -2998,7 +3188,22 @@ function postMountWrapper$3(element, props, isHydrating) {
     node.name = "";
   }
 
-  {
+  if (disableInputAttributeSyncing) {
+    // When not syncing the checked attribute, the checked property
+    // never gets assigned. It must be manually set. We don't want
+    // to do this when hydrating so that existing user input isn't
+    // modified
+    if (!isHydrating) {
+      updateChecked(element, props);
+    } // Only assign the checked attribute if it is defined. This saves
+    // a DOM write when controlling the checked attribute isn't needed
+    // (text inputs, submit/reset)
+
+    if (props.hasOwnProperty("defaultChecked")) {
+      node.defaultChecked = !node.defaultChecked;
+      node.defaultChecked = !!props.defaultChecked;
+    }
+  } else {
     // When syncing the checked attribute, both the checked property and
     // attribute are assigned at the same time using defaultChecked. This uses:
     //
@@ -3559,6 +3764,23 @@ var reusableSVGContainer;
 
 var setInnerHTML = createMicrosoftUnsafeLocalFunction(function (node, html) {
   if (node.namespaceURI === SVG_NAMESPACE) {
+    {
+      if (enableTrustedTypesIntegration) {
+        // TODO: reconsider the text of this warning and when it should show
+        // before enabling the feature flag.
+        if (typeof trustedTypes !== "undefined") {
+          error(
+            "Using 'dangerouslySetInnerHTML' in an svg element with " +
+              "Trusted Types enabled in an Internet Explorer will cause " +
+              "the trusted value to be converted to string. Assigning string " +
+              "to 'innerHTML' will throw an error if Trusted Types are enforced. " +
+              "You can try to wrap your svg element inside a div and use 'dangerouslySetInnerHTML' " +
+              "on the enclosing div instead."
+          );
+        }
+      }
+    }
+
     if (!("innerHTML" in node)) {
       // IE does not have innerHTML for SVG nodes, so instead we inject the
       // new markup in a temp node and then move the child nodes across into
@@ -5298,6 +5520,7 @@ function validateProperties(type, props, eventRegistry) {
 }
 
 var didWarnInvalidHydration = false;
+var didWarnScriptTags = false;
 var DANGEROUSLY_SET_INNER_HTML = "dangerouslySetInnerHTML";
 var SUPPRESS_CONTENT_EDITABLE_WARNING = "suppressContentEditableWarning";
 var SUPPRESS_HYDRATION_WARNING$1 = "suppressHydrationWarning";
@@ -5585,6 +5808,19 @@ function createPotentiallyInlineScriptElement(ownerDocument) {
   // set to true and it does not execute
   var div = ownerDocument.createElement("div");
 
+  {
+    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;
+    }
+  }
+
   div.innerHTML = "<script><" + "/script>"; // eslint-disable-line
   // This is guaranteed to yield a script element.
 
@@ -6301,10 +6537,36 @@ function diffHydratedProperties(
             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());
+
+        {
+          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);
+        serverValue = getValueForAttribute(
+          domElement,
+          propKey,
+          nextProp,
+          isCustomComponentTag
+        );
 
         if (nextProp !== serverValue) {
           warnForPropDifference(propKey, serverValue, nextProp);
@@ -6356,10 +6618,18 @@ function diffHydratedProperties(
             extraAttributeNames.delete(propKey);
           }
 
-          serverValue = getValueForAttribute(domElement, propKey, nextProp);
+          serverValue = getValueForAttribute(
+            domElement,
+            propKey,
+            nextProp,
+            isCustomComponentTag
+          );
         }
 
-        var dontWarnCustomElement = enableCustomElementPropertySupport;
+        var dontWarnCustomElement =
+          enableCustomElementPropertySupport &&
+          isCustomComponentTag &&
+          (typeof nextProp === "function" || typeof nextProp === "object");
 
         if (
           !dontWarnCustomElement &&
@@ -7459,17 +7729,23 @@ var scheduleCallback$2 = Scheduler.unstable_scheduleCallback;
 var cancelCallback$1 = Scheduler.unstable_cancelCallback;
 var shouldYield = Scheduler.unstable_shouldYield;
 var requestPaint = Scheduler.unstable_requestPaint;
-var now = Scheduler.unstable_now;
+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 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
@@ -7498,7 +7774,15 @@ function injectInternals(internals) {
   }
 
   try {
-    if (enableSchedulingProfiler);
+    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
+      });
+    }
 
     rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
 
@@ -7541,10 +7825,37 @@ function onCommitRoot$1(root, eventPriority) {
     try {
       var didError = (root.current.flags & DidCapture) === DidCapture;
 
-      var schedulerPriority;
-      if (enableProfilerTimer);
-      else {
-        injectedHook.onCommitFiberRoot(rendererID, root, undefined, didError);
+      if (enableProfilerTimer) {
+        var schedulerPriority;
+
+        switch (eventPriority) {
+          case DiscreteEventPriority:
+            schedulerPriority = ImmediatePriority;
+            break;
+
+          case ContinuousEventPriority:
+            schedulerPriority = UserBlockingPriority;
+            break;
+
+          case DefaultEventPriority:
+            schedulerPriority = NormalPriority$1;
+            break;
+
+          case IdleEventPriority:
+            schedulerPriority = IdlePriority;
+            break;
+
+          default:
+            schedulerPriority = NormalPriority$1;
+            break;
+        }
+
+        injectedHook.onCommitFiberRoot(
+          rendererID,
+          root,
+          schedulerPriority,
+          didError
+        );
       }
     } catch (err) {
       {
@@ -7590,15 +7901,302 @@ function onCommitUnmount(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) {}
+function injectProfilingHooks(profilingHooks) {
+  injectedProfilingHooks = profilingHooks;
+}
 
 function getLaneLabelMap() {
-  {
+  if (enableSchedulingProfiler) {
+    var map = new Map();
+    var lane = 1;
+
+    for (var index = 0; index < TotalLanes; index++) {
+      var label = getLabelForLane(lane);
+      map.set(lane, label);
+      lane *= 2;
+    }
+
+    return map;
+  } else {
     return null;
   }
 }
 
+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 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 NoMode =
   /*                         */
   0; // TODO: Remove ConcurrentMode by reading from the root tag instead
@@ -7609,6 +8207,9 @@ var ConcurrentMode =
 var ProfileMode =
   /*                    */
   2;
+var DebugTracingMode =
+  /*               */
+  4;
 var StrictLegacyMode =
   /*               */
   8;
@@ -7624,7 +8225,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 = Math.log;
+var log$1 = Math.log;
 var LN2 = Math.LN2;
 
 function clz32Fallback(x) {
@@ -7634,7 +8235,7 @@ function clz32Fallback(x) {
     return 32;
   }
 
-  return (31 - ((log(asUint) / LN2) | 0)) | 0;
+  return (31 - ((log$1(asUint) / LN2) | 0)) | 0;
 }
 
 // If those values are changed that package should be rebuilt and redeployed.
@@ -7664,6 +8265,9 @@ var DefaultHydrationLane =
 var DefaultLane =
   /*                     */
   32;
+var SyncUpdateLanes =
+  /*                */
+  42;
 var TransitionHydrationLane =
   /*                */
   64;
@@ -7749,11 +8353,76 @@ var IdleLane =
 var OffscreenLane =
   /*                   */
   1073741824; // This function is used for the experimental timeline (react-devtools-timeline)
+// It should be kept in sync with the Lanes values above.
+
+function getLabelForLane(lane) {
+  if (enableSchedulingProfiler) {
+    if (lane & SyncHydrationLane) {
+      return "SyncHydrationLane";
+    }
+
+    if (lane & SyncLane) {
+      return "Sync";
+    }
+
+    if (lane & InputContinuousHydrationLane) {
+      return "InputContinuousHydration";
+    }
+
+    if (lane & InputContinuousLane) {
+      return "InputContinuous";
+    }
+
+    if (lane & DefaultHydrationLane) {
+      return "DefaultHydration";
+    }
+
+    if (lane & DefaultLane) {
+      return "Default";
+    }
+
+    if (lane & TransitionHydrationLane) {
+      return "TransitionHydration";
+    }
+
+    if (lane & TransitionLanes) {
+      return "Transition";
+    }
+
+    if (lane & RetryLanes) {
+      return "Retry";
+    }
+
+    if (lane & SelectiveHydrationLane) {
+      return "SelectiveHydration";
+    }
+
+    if (lane & IdleHydrationLane) {
+      return "IdleHydration";
+    }
+
+    if (lane & IdleLane) {
+      return "Idle";
+    }
+
+    if (lane & OffscreenLane) {
+      return "Offscreen";
+    }
+  }
+}
 var NoTimestamp = -1;
 var nextTransitionLane = TransitionLane1;
 var nextRetryLane = RetryLane1;
 
 function getHighestPriorityLanes(lanes) {
+  if (enableUnifiedSyncLane) {
+    var pendingSyncLanes = lanes & SyncUpdateLanes;
+
+    if (pendingSyncLanes !== 0) {
+      return pendingSyncLanes;
+    }
+  }
+
   switch (getHighestPriorityLane(lanes)) {
     case SyncHydrationLane:
       return SyncHydrationLane;
@@ -8337,7 +9006,9 @@ function getBumpedLaneForHydration(root, renderLanes) {
   var renderLane = getHighestPriorityLane(renderLanes);
   var lane;
 
-  {
+  if (enableUnifiedSyncLane && (renderLane & SyncUpdateLanes) !== NoLane) {
+    lane = SyncHydrationLane;
+  } else {
     switch (renderLane) {
       case SyncLane:
         lane = SyncHydrationLane;
@@ -8395,10 +9066,105 @@ function getBumpedLaneForHydration(root, renderLanes) {
 
   return lane;
 }
+function addFiberToLanesMap(root, fiber, lanes) {
+  if (!isDevToolsPresent) {
+    return;
+  }
+
+  var pendingUpdatersLaneMap = root.pendingUpdatersLaneMap;
+
+  while (lanes > 0) {
+    var index = laneToIndex(lanes);
+    var lane = 1 << index;
+    var updaters = pendingUpdatersLaneMap[index];
+    updaters.add(fiber);
+    lanes &= ~lane;
+  }
+}
+function movePendingFibersToMemoized(root, lanes) {
+  if (!isDevToolsPresent) {
+    return;
+  }
+
+  var pendingUpdatersLaneMap = root.pendingUpdatersLaneMap;
+  var memoizedUpdaters = root.memoizedUpdaters;
+
+  while (lanes > 0) {
+    var index = laneToIndex(lanes);
+    var lane = 1 << index;
+    var updaters = pendingUpdatersLaneMap[index];
+
+    if (updaters.size > 0) {
+      updaters.forEach(function (fiber) {
+        var alternate = fiber.alternate;
+
+        if (alternate === null || !memoizedUpdaters.has(alternate)) {
+          memoizedUpdaters.add(fiber);
+        }
+      });
+      updaters.clear();
+    }
+
+    lanes &= ~lane;
+  }
+}
+function addTransitionToLanesMap(root, transition, lane) {
+  if (enableTransitionTracing) {
+    var transitionLanesMap = root.transitionLanes;
+    var index = laneToIndex(lane);
+    var transitions = transitionLanesMap[index];
+
+    if (transitions === null) {
+      transitions = new Set();
+    }
+
+    transitions.add(transition);
+    transitionLanesMap[index] = transitions;
+  }
+}
 function getTransitionsForLanes(root, lanes) {
-  {
+  if (!enableTransitionTracing) {
+    return null;
+  }
+
+  var transitionsForLanes = [];
+
+  while (lanes > 0) {
+    var index = laneToIndex(lanes);
+    var lane = 1 << index;
+    var transitions = root.transitionLanes[index];
+
+    if (transitions !== null) {
+      transitions.forEach(function (transition) {
+        transitionsForLanes.push(transition);
+      });
+    }
+
+    lanes &= ~lane;
+  }
+
+  if (transitionsForLanes.length === 0) {
     return null;
   }
+
+  return transitionsForLanes;
+}
+function clearTransitionsForLanes(root, lanes) {
+  if (!enableTransitionTracing) {
+    return;
+  }
+
+  while (lanes > 0) {
+    var index = laneToIndex(lanes);
+    var lane = 1 << index;
+    var transitions = root.transitionLanes[index];
+
+    if (transitions !== null) {
+      root.transitionLanes[index] = null;
+    }
+
+    lanes &= ~lane;
+  }
 }
 
 var DiscreteEventPriority = SyncLane;
@@ -9088,6 +9854,223 @@ function throwError(error) {
   throw error;
 }
 
+var nativeConsole = console;
+var nativeConsoleLog = null;
+var pendingGroupArgs = [];
+var printedGroupIndex = -1;
+
+function formatLanes(laneOrLanes) {
+  return "0b" + laneOrLanes.toString(2).padStart(31, "0");
+}
+
+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 groupEnd() {
+  pendingGroupArgs.pop();
+
+  while (printedGroupIndex >= pendingGroupArgs.length) {
+    nativeConsole.groupEnd();
+    printedGroupIndex--;
+  }
+
+  if (pendingGroupArgs.length === 0) {
+    nativeConsole.log = nativeConsoleLog;
+    nativeConsoleLog = 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);
+    }
+
+    printedGroupIndex = pendingGroupArgs.length - 1;
+  }
+
+  if (typeof nativeConsoleLog === "function") {
+    nativeConsoleLog.apply(void 0, arguments);
+  } else {
+    nativeConsole.log.apply(nativeConsole, arguments);
+  }
+}
+
+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();
+    }
+  }
+}
+var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe: Flow cannot handle polymorphic WeakMaps
+
+var wakeableIDs = new PossiblyWeakMap$1();
+var wakeableID = 0;
+
+function getWakeableID(wakeable) {
+  if (!wakeableIDs.has(wakeable)) {
+    wakeableIDs.set(wakeable, wakeableID++);
+  }
+
+  return wakeableIDs.get(wakeable);
+}
+
+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 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
+      );
+    }
+  }
+}
+
 // 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.
@@ -9305,6 +10288,11 @@ function markDidThrowWhileHydratingDEV() {
     didSuspendOrErrorDEV = true;
   }
 }
+function didSuspendOrErrorWhileHydratingDEV() {
+  {
+    return didSuspendOrErrorDEV;
+  }
+}
 
 function enterHydrationState(fiber) {
   var parentInstance = fiber.stateNode.containerInfo;
@@ -10372,7 +11360,7 @@ function enqueueUpdate(fiber, update, lane) {
     }
   }
 
-  if (isUnsafeClassRenderPhaseUpdate()) {
+  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;
@@ -10524,6 +11512,16 @@ function getStateFromUpdate(
         var nextState = payload.call(instance, prevState, nextProps);
 
         {
+          if (workInProgress.mode & StrictLegacyMode) {
+            setIsStrictModeForDevtools(true);
+
+            try {
+              payload.call(instance, prevState, nextProps);
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
+
           exitDisallowedContextReadInDEV();
         }
 
@@ -10552,6 +11550,16 @@ function getStateFromUpdate(
         partialState = _payload.call(instance, prevState, nextProps);
 
         {
+          if (workInProgress.mode & StrictLegacyMode) {
+            setIsStrictModeForDevtools(true);
+
+            try {
+              _payload.call(instance, prevState, nextProps);
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
+
           exitDisallowedContextReadInDEV();
         }
       } else {
@@ -13487,7 +14495,8 @@ function renderWithHooks(
   //
   // There are plenty of tests to ensure this behavior is correct.
 
-  var shouldDoubleRenderDEV = debugRenderPhaseSideEffectsForStrictMode;
+  var shouldDoubleRenderDEV =
+    (workInProgress.mode & StrictLegacyMode) !== NoMode;
   shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
   var children = Component(props, secondArg);
   shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
@@ -13503,6 +14512,22 @@ function renderWithHooks(
     );
   }
 
+  if (shouldDoubleRenderDEV) {
+    // In development, components are invoked twice to help detect side effects.
+    setIsStrictModeForDevtools(true);
+
+    try {
+      children = renderWithHooksAgain(
+        workInProgress,
+        Component,
+        props,
+        secondArg
+      );
+    } finally {
+      setIsStrictModeForDevtools(false);
+    }
+  }
+
   finishRenderingHooks(current, workInProgress);
   return children;
 }
@@ -13560,6 +14585,28 @@ function finishRenderingHooks(current, workInProgress) {
     );
   }
 
+  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();
+        }
+      }
+    }
+  }
+
   {
     if (checkIfUseWrappedInTryCatch()) {
       var componentName =
@@ -13841,7 +14888,8 @@ var createFunctionComponentUpdateQueue;
     return {
       lastEffect: null,
       events: null,
-      stores: null
+      stores: null,
+      memoCache: null
     };
   };
 }
@@ -13890,6 +14938,73 @@ function use(usable) {
   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
+
+  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;
+
+    if (current !== null) {
+      var currentUpdateQueue = current.updateQueue;
+
+      if (currentUpdateQueue !== null) {
+        var currentMemoCache = currentUpdateQueue.memoCache;
+
+        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
+
+  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);
+
+    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
+      );
+    }
+  }
+
+  memoCache.index++;
+  return data;
+}
+
 function basicStateReducer(state, action) {
   // $FlowFixMe: Flow doesn't like mixed types
   return typeof action === "function" ? action(state) : action;
@@ -14670,10 +15785,86 @@ function pushEffect(tag, create, destroy, deps) {
   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");
+  }
+
+  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 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;
+
+              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"
+              );
+            }
+          }
+
+          return current;
+        },
+
+        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;
+        }
+      };
+      Object.seal(ref);
+      hook.memoizedState = ref;
+      return ref;
+    }
+  } else {
     var _ref2 = {
       current: initialValue
     };
@@ -14744,6 +15935,62 @@ function updateEffect(create, deps) {
   updateEffectImpl(Passive$1, Passive, create, deps);
 }
 
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= Update;
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.events = [payload];
+  } else {
+    var events = componentUpdateQueue.events;
+
+    if (events === null) {
+      componentUpdateQueue.events = [payload];
+    } else {
+      events.push(payload);
+    }
+  }
+}
+
+function mountEvent(callback) {
+  var hook = mountWorkInProgressHook();
+  var ref = {
+    impl: callback
+  };
+  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 ref.impl.apply(undefined, arguments);
+  };
+}
+
+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."
+      );
+    }
+
+    return ref.impl.apply(undefined, arguments);
+  };
+}
+
 function mountInsertionEffect(create, deps) {
   mountEffectImpl(Update, Insertion, create, deps);
 }
@@ -14990,6 +16237,13 @@ function startTransition(setPending, callback, options) {
   ReactCurrentBatchConfig$3.transition = {};
   var currentTransition = ReactCurrentBatchConfig$3.transition;
 
+  if (enableTransitionTracing) {
+    if (options !== undefined && options.name !== undefined) {
+      ReactCurrentBatchConfig$3.transition.name = options.name;
+      ReactCurrentBatchConfig$3.transition.startTime = now$1();
+    }
+  }
+
   {
     ReactCurrentBatchConfig$3.transition._updatedFibers = new Set();
   }
@@ -15179,6 +16433,8 @@ function dispatchReducerAction(fiber, queue, action) {
       entangleTransitionUpdate(root, queue, lane);
     }
   }
+
+  markUpdateInDevTools(fiber, lane, action);
 }
 
 function dispatchSetState(fiber, queue, action) {
@@ -15261,6 +16517,8 @@ function dispatchSetState(fiber, queue, action) {
       entangleTransitionUpdate(root, queue, lane);
     }
   }
+
+  markUpdateInDevTools(fiber, lane, action);
 }
 
 function isRenderPhaseUpdate(fiber) {
@@ -15309,6 +16567,21 @@ function entangleTransitionUpdate(root, queue, lane) {
   }
 }
 
+function markUpdateInDevTools(fiber, lane, action) {
+  {
+    if (enableDebugTracing) {
+      if (fiber.mode & DebugTracingMode) {
+        var name = getComponentNameFromFiber(fiber) || "Unknown";
+        logStateUpdateScheduled(name, lane, action);
+      }
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markStateUpdateScheduled(fiber, lane);
+  }
+}
+
 var ContextOnlyDispatcher = {
   readContext: readContext,
   useCallback: throwInvalidHookError,
@@ -15337,6 +16610,14 @@ var ContextOnlyDispatcher = {
   ContextOnlyDispatcher.use = throwInvalidHookError;
 }
 
+{
+  ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+}
+
 var HooksDispatcherOnMountInDEV = null;
 var HooksDispatcherOnMountWithHookTypesInDEV = null;
 var HooksDispatcherOnUpdateInDEV = null;
@@ -15492,6 +16773,20 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     HooksDispatcherOnMountInDEV.use = use;
   }
 
+  {
+    HooksDispatcherOnMountInDEV.useMemoCache = useMemoCache;
+  }
+
+  {
+    HooksDispatcherOnMountInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      mountHookTypesDev();
+      return mountEvent(callback);
+    };
+  }
+
   HooksDispatcherOnMountWithHookTypesInDEV = {
     readContext: function (context) {
       return readContext(context);
@@ -15615,6 +16910,19 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     HooksDispatcherOnMountWithHookTypesInDEV.use = use;
   }
 
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useMemoCache = useMemoCache;
+  }
+
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        updateHookTypesDev();
+        return mountEvent(callback);
+      };
+  }
+
   HooksDispatcherOnUpdateInDEV = {
     readContext: function (context) {
       return readContext(context);
@@ -15737,6 +17045,20 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     HooksDispatcherOnUpdateInDEV.use = use;
   }
 
+  {
+    HooksDispatcherOnUpdateInDEV.useMemoCache = useMemoCache;
+  }
+
+  {
+    HooksDispatcherOnUpdateInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      updateHookTypesDev();
+      return updateEvent(callback);
+    };
+  }
+
   HooksDispatcherOnRerenderInDEV = {
     readContext: function (context) {
       return readContext(context);
@@ -15860,6 +17182,20 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     HooksDispatcherOnRerenderInDEV.use = use;
   }
 
+  {
+    HooksDispatcherOnRerenderInDEV.useMemoCache = useMemoCache;
+  }
+
+  {
+    HooksDispatcherOnRerenderInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      updateHookTypesDev();
+      return updateEvent(callback);
+    };
+  }
+
   InvalidNestedHooksDispatcherOnMountInDEV = {
     readContext: function (context) {
       warnInvalidContextAccess();
@@ -16003,6 +17339,23 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     };
   }
 
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
+  }
+
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountEvent(callback);
+      };
+  }
+
   InvalidNestedHooksDispatcherOnUpdateInDEV = {
     readContext: function (context) {
       warnInvalidContextAccess();
@@ -16146,6 +17499,23 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     };
   }
 
+  {
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
+  }
+
+  {
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEvent(callback);
+      };
+  }
+
   InvalidNestedHooksDispatcherOnRerenderInDEV = {
     readContext: function (context) {
       warnInvalidContextAccess();
@@ -16288,17 +17658,188 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
       return use(usable);
     };
   }
+
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
+  }
+
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEvent(callback);
+      };
+  }
 }
 
-function recordLayoutEffectDuration(fiber) {
+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 currentUpdateIsNested = false;
+var nestedUpdateScheduled = false;
+
+function isCurrentUpdateNested() {
+  return currentUpdateIsNested;
+}
+
+function markNestedUpdateScheduled() {
   {
-    return;
+    nestedUpdateScheduled = true;
   }
 }
 
-function startLayoutEffectTimer() {
+function resetNestedUpdateFlag() {
   {
-    return;
+    currentUpdateIsNested = false;
+    nestedUpdateScheduled = false;
+  }
+}
+
+function syncNestedUpdateFlag() {
+  {
+    currentUpdateIsNested = nestedUpdateScheduled;
+    nestedUpdateScheduled = false;
+  }
+}
+
+function getCommitTime() {
+  return commitTime;
+}
+
+function recordCommitTime() {
+  commitTime = now();
+}
+
+function startProfilerTimer(fiber) {
+  profilerStartTime = now();
+
+  if (fiber.actualStartTime < 0) {
+    fiber.actualStartTime = now();
+  }
+}
+
+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 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;
+    }
+  }
+}
+
+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 parentFiber = fiber.return;
+
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          var root = parentFiber.stateNode;
+
+          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 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;
   }
 }
 
@@ -16408,6 +17949,17 @@ function applyDerivedStateFromProps(
   var partialState = getDerivedStateFromProps(nextProps, prevState);
 
   {
+    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.
 
@@ -16449,6 +18001,19 @@ var classComponentUpdater = {
       scheduleUpdateOnFiber(root, fiber, lane, eventTime);
       entangleTransitions(root, fiber, lane);
     }
+
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logStateUpdateScheduled(name, lane, payload);
+        }
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markStateUpdateScheduled(fiber, lane);
+    }
   },
   enqueueReplaceState: function (inst, payload, callback) {
     var fiber = get(inst);
@@ -16472,6 +18037,19 @@ var classComponentUpdater = {
       scheduleUpdateOnFiber(root, fiber, lane, eventTime);
       entangleTransitions(root, fiber, lane);
     }
+
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logStateUpdateScheduled(name, lane, payload);
+        }
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markStateUpdateScheduled(fiber, lane);
+    }
   },
   // $FlowFixMe[missing-local-annot]
   enqueueForceUpdate: function (inst, callback) {
@@ -16495,6 +18073,19 @@ var classComponentUpdater = {
       scheduleUpdateOnFiber(root, fiber, lane, eventTime);
       entangleTransitions(root, fiber, lane);
     }
+
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logForceUpdateScheduled(name, lane);
+        }
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markForceUpdateScheduled(fiber, lane);
+    }
   }
 };
 
@@ -16517,6 +18108,21 @@ function checkShouldComponentUpdate(
     );
 
     {
+      if (workInProgress.mode & StrictLegacyMode) {
+        setIsStrictModeForDevtools(true);
+
+        try {
+          // Invoke the function an extra time to help detect side-effects.
+          shouldUpdate = instance.shouldComponentUpdate(
+            newProps,
+            newState,
+            nextContext
+          );
+        } finally {
+          setIsStrictModeForDevtools(false);
+        }
+      }
+
       if (shouldUpdate === undefined) {
         error(
           "%s.shouldComponentUpdate(): Returned undefined instead of a " +
@@ -16835,6 +18441,18 @@ function constructClassInstance(workInProgress, ctor, props) {
 
   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 state = (workInProgress.memoizedState =
     instance.state !== null && instance.state !== undefined
       ? instance.state
@@ -17296,7 +18914,12 @@ function updateClassInstance(
     oldState === newState &&
     !hasContextChanged() &&
     !checkHasForceUpdateAfterProcessing() &&
-    !enableLazyContextPropagation
+    !(
+      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.
@@ -17345,7 +18968,10 @@ function updateClassInstance(
     // 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;
+    (enableLazyContextPropagation &&
+      current !== null &&
+      current.dependencies !== null &&
+      checkIfContextChanged(current.dependencies));
 
   if (shouldUpdate) {
     // In order to support react-lifecycles-compat polyfilled components,
@@ -17605,6 +19231,23 @@ function createClassErrorUpdate(fiber, errorInfo, lane) {
 }
 
 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;
@@ -17750,6 +19393,13 @@ function throwException(
   // The source fiber did not complete.
   sourceFiber.flags |= Incomplete;
 
+  {
+    if (isDevToolsPresent) {
+      // If we have pending work still, restore the original updaters
+      restorePendingUpdaters(root, rootRenderLanes);
+    }
+  }
+
   if (
     value !== null &&
     typeof value === "object" &&
@@ -17757,7 +19407,7 @@ function throwException(
   ) {
     // This is a wakeable. The component suspended.
     var wakeable = value;
-    resetSuspendedComponent(sourceFiber);
+    resetSuspendedComponent(sourceFiber, rootRenderLanes);
 
     {
       if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
@@ -17765,6 +19415,15 @@ function throwException(
       }
     }
 
+    {
+      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 suspenseBoundary = getSuspenseHandler();
 
     if (suspenseBoundary !== null) {
@@ -17990,6 +19649,207 @@ function throwException(
   } while (workInProgress !== null);
 }
 
+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 (transitionStart !== null && onTransitionStart != null) {
+        transitionStart.forEach(function (transition) {
+          return onTransitionStart(transition.name, transition.startTime);
+        });
+      }
+
+      var markerProgress = pendingTransitions.markerProgress;
+      var onMarkerProgress = callbacks.onMarkerProgress;
+
+      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 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
+            );
+          });
+        });
+      }
+
+      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;
+                }
+              }
+            });
+
+            if (filteredAborts.length > 0) {
+              onMarkerIncomplete(
+                transition.name,
+                markerName,
+                transition.startTime,
+                filteredAborts
+              );
+            }
+          });
+        });
+      }
+
+      var transitionProgress = pendingTransitions.transitionProgress;
+      var onTransitionProgress = callbacks.onTransitionProgress;
+
+      if (onTransitionProgress != null && transitionProgress !== null) {
+        transitionProgress.forEach(function (pending, transition) {
+          onTransitionProgress(
+            transition.name,
+            transition.startTime,
+            endTime,
+            Array.from(pending.values())
+          );
+        });
+      }
+
+      var transitionComplete = pendingTransitions.transitionComplete;
+      var onTransitionComplete = callbacks.onTransitionComplete;
+
+      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 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 (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);
+        }
+      });
+    }
+
+    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.
+
+    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
+      );
+    }
+  }
+}
+function popMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    pop(markerInstanceStack, workInProgress);
+  }
+}
+function getMarkerInstances() {
+  if (enableTransitionTracing) {
+    return markerInstanceStack.current;
+  }
+
+  return null;
+}
+
 var ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
 // into a dehydrated boundary.
 
@@ -18114,6 +19974,10 @@ function updateForwardRef(
   var hasId;
   prepareToReadContext(workInProgress, renderLanes);
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
+
   {
     ReactCurrentOwner$2.current = workInProgress;
     setIsRendering(true);
@@ -18129,6 +19993,10 @@ function updateForwardRef(
     setIsRendering(false);
   }
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
+
   if (current !== null && !didReceiveUpdate) {
     bailoutHooks(current, workInProgress, renderLanes);
     return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
@@ -18384,7 +20252,11 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
   var prevState = current !== null ? current.memoizedState : null;
   markRef$1(current, workInProgress);
 
-  if (nextProps.mode === "hidden" || enableLegacyHidden || nextIsDetached) {
+  if (
+    nextProps.mode === "hidden" ||
+    nextProps.mode === "unstable-defer-without-hiding" ||
+    nextIsDetached
+  ) {
     // Rendering a hidden tree.
     var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
 
@@ -18427,7 +20299,8 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
       return deferHiddenOffscreenComponent(
         current,
         workInProgress,
-        nextBaseLanes
+        nextBaseLanes,
+        renderLanes
       );
     }
 
@@ -18444,7 +20317,7 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         // 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);
+          pushTransition(workInProgress, null, null);
         }
       }
 
@@ -18465,7 +20338,8 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
       return deferHiddenOffscreenComponent(
         current,
         workInProgress,
-        _nextBaseLanes
+        _nextBaseLanes,
+        renderLanes
       );
     } else {
       // This is the second render. The surrounding visible content has already
@@ -18484,7 +20358,7 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         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);
+        pushTransition(workInProgress, prevCachePool, null);
       } // Push the lanes that were skipped when we bailed out.
 
       if (prevState !== null) {
@@ -18508,7 +20382,19 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         _prevCachePool = prevState.cachePool;
       }
 
-      pushTransition(workInProgress, _prevCachePool); // Push the lanes that were skipped when we bailed out.
+      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
@@ -18523,7 +20409,7 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         // using the same cache. Unless the parent changed, since that means
         // there was a refresh.
         if (current !== null) {
-          pushTransition(workInProgress, 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.
@@ -18554,7 +20440,7 @@ function deferHiddenOffscreenComponent(
     // 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);
+      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.
@@ -18562,8 +20448,23 @@ function deferHiddenOffscreenComponent(
   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 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);
@@ -18624,6 +20525,53 @@ function updateCacheComponent(current, workInProgress, 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
+
+  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."
+        );
+      }
+    }
+  }
+
+  var instance = workInProgress.stateNode;
+
+  if (instance !== null) {
+    pushMarkerInstance(workInProgress, instance);
+  }
+
+  var nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
 function updateFragment(current, workInProgress, renderLanes) {
   var nextChildren = workInProgress.pendingProps;
   reconcileChildren(current, workInProgress, nextChildren, renderLanes);
@@ -18637,6 +20585,18 @@ function updateMode(current, workInProgress, renderLanes) {
 }
 
 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;
+    }
+  }
+
   var nextProps = workInProgress.pendingProps;
   var nextChildren = nextProps.children;
   reconcileChildren(current, workInProgress, nextChildren, renderLanes);
@@ -18691,6 +20651,10 @@ function updateFunctionComponent(
   var hasId;
   prepareToReadContext(workInProgress, renderLanes);
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
+
   {
     ReactCurrentOwner$2.current = workInProgress;
     setIsRendering(true);
@@ -18706,6 +20670,10 @@ function updateFunctionComponent(
     setIsRendering(false);
   }
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
+
   if (current !== null && !didReceiveUpdate) {
     bailoutHooks(current, workInProgress, renderLanes);
     return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
@@ -18739,6 +20707,10 @@ function replayFunctionComponent(
 
   prepareToReadContext(workInProgress, renderLanes);
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
+
   var nextChildren = replaySuspendedComponentWithHooks(
     current,
     workInProgress,
@@ -18748,6 +20720,10 @@ function replayFunctionComponent(
   );
   var hasId = checkDidRenderIdHook();
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
+
   if (current !== null && !didReceiveUpdate) {
     bailoutHooks(current, workInProgress, renderLanes);
     return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
@@ -18925,13 +20901,35 @@ function finishClassComponent(
     // 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);
+        }
+      }
+
       setIsRendering(false);
     }
+
+    if (enableSchedulingProfiler) {
+      markComponentRenderStopped();
+    }
   } // React DevTools reads this flag.
 
   workInProgress.flags |= PerformedWork;
@@ -18992,6 +20990,11 @@ function updateHostRoot(current, workInProgress, renderLanes) {
   processUpdateQueue(workInProgress, nextProps, null, renderLanes);
   var nextState = workInProgress.memoizedState;
   var root = workInProgress.stateNode;
+  pushRootTransition(workInProgress);
+
+  if (enableTransitionTracing) {
+    pushRootMarkerInstance(workInProgress);
+  }
 
   {
     var nextCache = nextState.cache;
@@ -19390,6 +21393,10 @@ function mountIndeterminateComponent(
   var value;
   var hasId;
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
+
   {
     if (
       Component.prototype &&
@@ -19427,6 +21434,10 @@ function mountIndeterminateComponent(
     setIsRendering(false);
   }
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
+
   workInProgress.flags |= PerformedWork;
 
   {
@@ -19716,6 +21727,27 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
         mountSuspenseOffscreenState(renderLanes);
       workInProgress.memoizedState = SUSPENDED_MARKER;
 
+      if (enableTransitionTracing) {
+        var currentTransitions = getPendingTransitions();
+
+        if (currentTransitions !== null) {
+          var parentMarkerInstances = getMarkerInstances();
+          var offscreenQueue = primaryChildFragment.updateQueue;
+
+          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
@@ -19788,6 +21820,41 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
           ? mountSuspenseOffscreenState(renderLanes)
           : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
 
+      if (enableTransitionTracing) {
+        var _currentTransitions = getPendingTransitions();
+
+        if (_currentTransitions !== null) {
+          var _parentMarkerInstances = getMarkerInstances();
+
+          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
@@ -19855,6 +21922,17 @@ function mountSuspenseFallbackChildren(
     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;
+    }
+
     fallbackChildFragment = createFiberFromFragment(
       fallbackChildren,
       mode,
@@ -19963,6 +22041,19 @@ function updateSuspenseFallbackChildren(
     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.
 
@@ -20179,6 +22270,17 @@ function updateDehydratedSuspenseComponent(
         capturedValue
       );
     }
+
+    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);
@@ -20785,7 +22887,8 @@ function updateContextProvider(current, workInProgress, renderLanes) {
 
   pushProvider(workInProgress, context, newValue);
 
-  {
+  if (enableLazyContextPropagation);
+  else {
     if (oldProps !== null) {
       var oldValue = oldProps.value;
 
@@ -20859,6 +22962,10 @@ function updateContextConsumer(current, workInProgress, renderLanes) {
   prepareToReadContext(workInProgress, renderLanes);
   var newValue = readContext(context);
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
+
   var newChildren;
 
   {
@@ -20868,6 +22975,10 @@ function updateContextConsumer(current, workInProgress, renderLanes) {
     setIsRendering(false);
   }
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
+
   workInProgress.flags |= PerformedWork;
   reconcileChildren(current, workInProgress, newChildren, renderLanes);
   return workInProgress.child;
@@ -20883,6 +22994,9 @@ function updateScopeComponent(current, workInProgress, renderLanes) {
 function markWorkInProgressReceivedUpdate() {
   didReceiveUpdate = true;
 }
+function checkIfWorkInProgressReceivedUpdate() {
+  return didReceiveUpdate;
+}
 
 function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
   if ((workInProgress.mode & ConcurrentMode) === NoMode) {
@@ -20905,13 +23019,26 @@ function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
     workInProgress.dependencies = current.dependencies;
   }
 
+  {
+    // 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);
+
+      if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
+        return null;
+      }
+    } else {
       return null;
     }
   } // This fiber doesn't have work, but its subtree does. Clone the child
@@ -20986,6 +23113,15 @@ function checkScheduledUpdateOrContext(current, renderLanes) {
   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;
+    }
+  }
 
   return false;
 }
@@ -21001,6 +23137,11 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
   switch (workInProgress.tag) {
     case HostRoot:
       pushHostRootContext(workInProgress);
+      pushRootTransition(workInProgress);
+
+      if (enableTransitionTracing) {
+        pushRootMarkerInstance(workInProgress);
+      }
 
       {
         var cache = current.memoizedState.cache;
@@ -21037,6 +23178,26 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
     }
 
     case Profiler:
+      {
+        // Profiler should only call onRender when one of its descendants actually rendered.
+        var hasChildWork = includesSomeLane(
+          renderLanes,
+          workInProgress.childLanes
+        );
+
+        if (hasChildWork) {
+          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;
+        }
+      }
+
       break;
 
     case SuspenseComponent: {
@@ -21104,6 +23265,25 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
         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 (didSuspendBefore) {
         if (_hasChildWork) {
           // If something was in fallback state last time, and we have all the
@@ -21169,6 +23349,16 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
 
       break;
     }
+
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        var instance = workInProgress.stateNode;
+
+        if (instance !== null) {
+          pushMarkerInstance(workInProgress, instance);
+        }
+      }
+    }
   }
 
   return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
@@ -21452,7 +23642,13 @@ function beginWork$1(current, workInProgress, renderLanes) {
     }
 
     case LegacyHiddenComponent: {
-      break;
+      {
+        return updateLegacyHiddenComponent(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      }
     }
 
     case CacheComponent: {
@@ -21460,6 +23656,18 @@ function beginWork$1(current, workInProgress, renderLanes) {
         return updateCacheComponent(current, workInProgress, renderLanes);
       }
     }
+
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        return updateTracingMarkerComponent(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      }
+
+      break;
+    }
   }
 
   throw new Error(
@@ -21588,12 +23796,28 @@ function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
   }
 }
 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) {
@@ -21730,6 +23954,285 @@ function propagateContextChange_eager(workInProgress, context, renderLanes) {
     fiber = nextFiber;
   }
 }
+
+function propagateContextChanges(
+  workInProgress,
+  contexts,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  // Only used by lazy 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;
+  }
+
+  while (fiber !== null) {
+    var nextFiber = void 0; // Visit this fiber.
+
+    var list = fiber.dependencies;
+
+    if (list !== null) {
+      nextFiber = fiber.child;
+      var dep = list.firstContext;
+
+      findChangedDep: while (dep !== null) {
+        // Assigning these to constants to help Flow
+        var dependency = dep;
+        var consumer = fiber;
+
+        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 (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 (alternate !== null) {
+              alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+            }
+
+            scheduleContextWorkOnParentPath(
+              consumer.return,
+              renderLanes,
+              workInProgress
+            );
+
+            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.
+
+            break findChangedDep;
+          }
+        }
+
+        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;
+
+      while (nextFiber !== null) {
+        if (nextFiber === workInProgress) {
+          // We're back to the root of this subtree. Exit.
+          nextFiber = null;
+          break;
+        }
+
+        var sibling = nextFiber.sibling;
+
+        if (sibling !== null) {
+          // Set the return pointer of the sibling to the work-in-progress fiber.
+          sibling.return = nextFiber.return;
+          nextFiber = sibling;
+          break;
+        } // No more siblings. Traverse up.
+
+        nextFiber = nextFiber.return;
+      }
+    }
+
+    fiber = nextFiber;
+  }
+}
+
+function 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.
+
+function propagateParentContextChangesToDeferredTree(
+  current,
+  workInProgress,
+  renderLanes
+) {
+  var forcePropagateEntireTree = true;
+  propagateParentContextChanges(
+    current,
+    workInProgress,
+    renderLanes,
+    forcePropagateEntireTree
+  );
+}
+
+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.
+
+  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;
+      }
+    }
+
+    if (parent.tag === ContextProvider) {
+      var currentParent = parent.alternate;
+
+      if (currentParent === null) {
+        throw new Error("Should have a current fiber. This is a bug in React.");
+      }
+
+      var oldProps = currentParent.memoizedProps;
+
+      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;
+  }
+
+  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;
+
+  while (dependency !== null) {
+    var context = dependency.context;
+    var newValue = context._currentValue;
+    var oldValue = dependency.memoizedValue;
+
+    if (!objectIs(newValue, oldValue)) {
+      return true;
+    }
+
+    dependency = dependency.next;
+  }
+
+  return false;
+}
 function prepareToReadContext(workInProgress, renderLanes) {
   currentlyRenderingFiber = workInProgress;
   lastContextDependency = null;
@@ -21737,7 +24240,10 @@ function prepareToReadContext(workInProgress, renderLanes) {
   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) {
@@ -21803,6 +24309,10 @@ function readContextForConsumer(consumer, context) {
         lanes: NoLanes,
         firstContext: contextItem
       };
+
+      if (enableLazyContextPropagation) {
+        consumer.flags |= NeedsPropagation;
+      }
     } else {
       // Append a new context item.
       lastContextDependency = lastContextDependency.next = contextItem;
@@ -21911,6 +24421,12 @@ function requestCurrentTransition() {
 // 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,
@@ -21956,6 +24472,17 @@ function requestCacheFromPool(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,
@@ -21968,14 +24495,39 @@ function pushTransition(
       push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
     }
   }
+
+  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);
+    }
+
     {
       pop(resumedCache, workInProgress);
     }
   }
 }
+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
@@ -22379,7 +24931,37 @@ function bubbleProperties(completedWork) {
 
   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) {
@@ -22400,7 +24982,30 @@ function bubbleProperties(completedWork) {
     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) {
@@ -22461,6 +25066,23 @@ function completeDehydratedSuspenseBoundary(
       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
@@ -22479,6 +25101,23 @@ function completeDehydratedSuspenseBoundary(
       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 {
@@ -22528,6 +25167,16 @@ function completeWork(current, workInProgress, renderLanes) {
     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;
 
@@ -22544,6 +25193,12 @@ function completeWork(current, workInProgress, renderLanes) {
 
         popCacheProvider(workInProgress);
       }
+
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(workInProgress);
+      }
+
+      popRootTransition(workInProgress);
       popHostContainer(workInProgress);
       popTopLevelContextObject(workInProgress);
       resetWorkInProgressVersions();
@@ -22588,6 +25243,15 @@ function completeWork(current, workInProgress, renderLanes) {
       }
       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;
     }
 
@@ -22830,6 +25494,10 @@ function completeWork(current, workInProgress, renderLanes) {
         // 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;
       }
 
@@ -22866,6 +25534,10 @@ function completeWork(current, workInProgress, renderLanes) {
       // a passive effect, which is when we process the transitions
 
       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
@@ -22902,6 +25574,21 @@ function completeWork(current, workInProgress, renderLanes) {
 
       bubbleProperties(workInProgress);
 
+      {
+        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 (primaryChildFragment !== null) {
+              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -=
+                primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
+
       return null;
     }
 
@@ -23016,7 +25703,7 @@ function completeWork(current, workInProgress, renderLanes) {
             }
           }
 
-          if (renderState.tail !== null && now() > getRenderTargetTime()) {
+          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.
@@ -23069,7 +25756,7 @@ function completeWork(current, workInProgress, renderLanes) {
             // 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() * 2 - renderState.renderingStartTime >
+            now$1() * 2 - renderState.renderingStartTime >
               getRenderTargetTime() &&
             renderLanes !== OffscreenLane
           ) {
@@ -23118,7 +25805,7 @@ function completeWork(current, workInProgress, renderLanes) {
         var next = renderState.tail;
         renderState.rendering = next;
         renderState.tail = next.sibling;
-        renderState.renderingStartTime = now();
+        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.
@@ -23178,7 +25865,8 @@ function completeWork(current, workInProgress, renderLanes) {
       var _nextState = workInProgress.memoizedState;
       var nextIsHidden = _nextState !== null; // Schedule a Visibility effect if the visibility has changed
 
-      {
+      if (workInProgress.tag === LegacyHiddenComponent);
+      else {
         if (current !== null) {
           var _prevState = current.memoizedState;
           var prevIsHidden = _prevState !== null;
@@ -23208,7 +25896,10 @@ function completeWork(current, workInProgress, renderLanes) {
           // If so, we need to hide those nodes in the commit phase, so
           // schedule a visibility effect.
 
-          if (workInProgress.subtreeFlags & (Placement | Update)) {
+          if (
+            workInProgress.tag !== LegacyHiddenComponent &&
+            workInProgress.subtreeFlags & (Placement | Update)
+          ) {
             workInProgress.flags |= Visibility;
           }
         }
@@ -23273,6 +25964,16 @@ function completeWork(current, workInProgress, renderLanes) {
     }
 
     case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        var _instance3 = workInProgress.stateNode;
+
+        if (_instance3 !== null) {
+          popMarkerInstance(workInProgress);
+        }
+
+        bubbleProperties(workInProgress);
+      }
+
       return null;
     }
   }
@@ -23305,6 +26006,10 @@ function unwindWork(current, workInProgress, renderLanes) {
       if (flags & ShouldCapture) {
         workInProgress.flags = (flags & ~ShouldCapture) | DidCapture;
 
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        }
+
         return workInProgress;
       }
 
@@ -23315,6 +26020,12 @@ function unwindWork(current, workInProgress, renderLanes) {
       {
         popCacheProvider(workInProgress);
       }
+
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(workInProgress);
+      }
+
+      popRootTransition(workInProgress);
       popHostContainer(workInProgress);
       popTopLevelContextObject(workInProgress);
       resetWorkInProgressVersions();
@@ -23361,6 +26072,10 @@ function unwindWork(current, workInProgress, renderLanes) {
       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;
       }
 
@@ -23393,6 +26108,10 @@ function unwindWork(current, workInProgress, renderLanes) {
       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;
       }
 
@@ -23407,6 +26126,12 @@ function unwindWork(current, workInProgress, renderLanes) {
       return null;
 
     case TracingMarkerComponent:
+      if (enableTransitionTracing) {
+        if (workInProgress.stateNode !== null) {
+          popMarkerInstance(workInProgress);
+        }
+      }
+
       return null;
 
     default:
@@ -23436,6 +26161,12 @@ function unwindInterruptedWork(current, interruptedWork, renderLanes) {
       {
         popCacheProvider(interruptedWork);
       }
+
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(interruptedWork);
+      }
+
+      popRootTransition(interruptedWork);
       popHostContainer(interruptedWork);
       popTopLevelContextObject(interruptedWork);
       resetWorkInProgressVersions();
@@ -23478,6 +26209,17 @@ function unwindInterruptedWork(current, interruptedWork, renderLanes) {
         popCacheProvider(interruptedWork);
       }
 
+      break;
+
+    case TracingMarkerComponent:
+      if (enableTransitionTracing) {
+        var instance = interruptedWork.stateNode;
+
+        if (instance !== null) {
+          popMarkerInstance(interruptedWork);
+        }
+      }
+
       break;
   }
 }
@@ -23582,6 +26324,9 @@ function rethrowCaughtError() {
     throw error;
   }
 }
+function hasCaughtError() {
+  return hasError;
+}
 function clearCaughtError() {
   if (hasError) {
     var error = caughtError;
@@ -23608,8 +26353,14 @@ 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 enableProfilerTimer;
+  return (
+    (current.mode & ProfileMode) !== NoMode &&
+    (getExecutionContext() & CommitContext) !== NoContext
+  );
 }
 
 function reportUncaughtErrorInDEV(error) {
@@ -23630,7 +26381,14 @@ var callComponentWillUnmountWithTimer = function (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.
@@ -23662,8 +26420,14 @@ function safelyDetachRef(current, nearestMountedAncestor) {
   if (ref !== null) {
     if (typeof refCleanup === "function") {
       try {
-        if (shouldProfile(current));
-        else {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            refCleanup();
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
           refCleanup();
         }
       } catch (error) {
@@ -23681,8 +26445,14 @@ function safelyDetachRef(current, nearestMountedAncestor) {
       var retVal;
 
       try {
-        if (shouldProfile(current));
-        else {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            retVal = ref(null);
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
           retVal = ref(null);
         }
       } catch (error) {
@@ -23806,6 +26576,12 @@ function commitBeforeMutationEffectsOnFiber(finishedWork) {
 
   switch (finishedWork.tag) {
     case FunctionComponent: {
+      {
+        if ((flags & Update) !== NoFlags$1) {
+          commitUseEffectEventMount(finishedWork);
+        }
+      }
+
       break;
     }
 
@@ -23947,6 +26723,14 @@ function commitHookEffectListUnmount(
         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);
@@ -23960,6 +26744,14 @@ function commitHookEffectListUnmount(
               setIsRunningInsertionEffect(false);
             }
           }
+
+          if (enableSchedulingProfiler) {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStopped();
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStopped();
+            }
+          }
         }
       }
 
@@ -23978,6 +26770,14 @@ function commitHookEffectListMount(flags, finishedWork) {
 
     do {
       if ((effect.tag & flags) === flags) {
+        if (enableSchedulingProfiler) {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStarted(finishedWork);
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStarted(finishedWork);
+          }
+        } // Mount
+
         var create = effect.create;
 
         {
@@ -23994,6 +26794,14 @@ function commitHookEffectListMount(flags, finishedWork) {
           }
         }
 
+        if (enableSchedulingProfiler) {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStopped();
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStopped();
+          }
+        }
+
         {
           var destroy = effect.destroy;
 
@@ -24050,12 +26858,87 @@ function commitHookEffectListMount(flags, finishedWork) {
   }
 }
 
+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;
+    }
+  }
+}
+
+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";
+
+          {
+            if (isCurrentUpdateNested()) {
+              phase = "nested-update";
+            }
+          }
+
+          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 parentFiber = finishedWork.return;
+
+          outer: while (parentFiber !== null) {
+            switch (parentFiber.tag) {
+              case HostRoot:
+                var root = parentFiber.stateNode;
+                root.passiveEffectDuration += passiveEffectDuration;
+                break outer;
+
+              case Profiler:
+                var parentStateNode = parentFiber.stateNode;
+                parentStateNode.passiveEffectDuration += passiveEffectDuration;
+                break outer;
+            }
+
+            parentFiber = parentFiber.return;
+          }
+
+          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);
+    }
+
+    recordLayoutEffectDuration(finishedWork);
+  } else {
     try {
       commitHookEffectListMount(hookFlags, finishedWork);
     } catch (error) {
@@ -24100,7 +26983,16 @@ function commitClassLayoutLifecycles(finishedWork, current) {
       }
     }
 
-    {
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+
+      recordLayoutEffectDuration(finishedWork);
+    } else {
       try {
         instance.componentDidMount();
       } catch (error) {
@@ -24145,7 +27037,20 @@ function commitClassLayoutLifecycles(finishedWork, current) {
       }
     }
 
-    {
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidUpdate(
+          prevProps,
+          prevState,
+          instance.__reactInternalSnapshotBeforeUpdate
+        );
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+
+      recordLayoutEffectDuration(finishedWork);
+    } else {
       try {
         instance.componentDidUpdate(
           prevProps,
@@ -24218,6 +27123,72 @@ function commitHostComponentMount(finishedWork) {
   }
 }
 
+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
+        );
+      }
+
+      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;
+
+        outer: while (parentFiber !== null) {
+          switch (parentFiber.tag) {
+            case HostRoot:
+              var root = parentFiber.stateNode;
+              root.effectDuration += effectDuration;
+              break outer;
+
+            case Profiler:
+              var parentStateNode = parentFiber.stateNode;
+              parentStateNode.effectDuration += effectDuration;
+              break outer;
+          }
+
+          parentFiber = parentFiber.return;
+        }
+      }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
 function commitLayoutEffectOnFiber(
   finishedRoot,
   current,
@@ -24327,6 +27298,11 @@ function commitLayoutEffectOnFiber(
 
     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);
+      }
 
       break;
     }
@@ -24402,6 +27378,271 @@ function commitLayoutEffectOnFiber(
   }
 }
 
+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 = [];
+        }
+
+        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
+            );
+          }
+        }
+      }
+    });
+  }
+}
+
+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
+
+            if (
+              deletedOffscreenInstance !== null &&
+              !isInDeletedTree &&
+              pendingBoundaries !== null &&
+              pendingBoundaries.has(deletedOffscreenInstance)
+            ) {
+              pendingBoundaries.delete(deletedOffscreenInstance);
+              addMarkerProgressCallbackToPendingTransition(
+                abortedFiber.memoizedProps.name,
+                deletedTransitions,
+                pendingBoundaries
+              );
+            }
+          }
+        }
+      });
+    }
+  }
+}
+
+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;
+
+    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;
+    }
+  }
+}
+
+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 (previousFiber !== null && previousFiber.memoizedState !== null) {
+      prevState = previousFiber.memoizedState;
+    }
+
+    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.
+
+    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;
+
+          if (
+            pendingBoundaries !== null &&
+            pendingBoundaries.has(offscreenInstance)
+          ) {
+            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
+                    );
+                  }
+
+                  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;
@@ -24507,7 +27748,14 @@ function commitAttachRef(finishedWork) {
     }
 
     if (typeof ref === "function") {
-      {
+      if (shouldProfile(finishedWork)) {
+        try {
+          startLayoutEffectTimer();
+          finishedWork.refCleanup = ref(instanceToUse);
+        } finally {
+          recordLayoutEffectDuration(finishedWork);
+        }
+      } else {
         finishedWork.refCleanup = ref(instanceToUse);
       }
     } else {
@@ -25049,13 +28297,29 @@ function commitDeletionEffectsOnFiber(
                     destroy
                   );
                 } else if ((tag & Layout) !== NoFlags) {
-                  {
+                  if (enableSchedulingProfiler) {
+                    markComponentLayoutEffectUnmountStarted(deletedFiber);
+                  }
+
+                  if (shouldProfile(deletedFiber)) {
+                    startLayoutEffectTimer();
+                    safelyCallDestroy(
+                      deletedFiber,
+                      nearestMountedAncestor,
+                      destroy
+                    );
+                    recordLayoutEffectDuration(deletedFiber);
+                  } else {
                     safelyCallDestroy(
                       deletedFiber,
                       nearestMountedAncestor,
                       destroy
                     );
                   }
+
+                  if (enableSchedulingProfiler) {
+                    markComponentLayoutEffectUnmountStopped();
+                  }
                 }
               }
 
@@ -25302,6 +28566,19 @@ function attachSuspenseRetryListeners(finishedWork, wakeables) {
     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."
+            );
+          }
+        }
+      }
+
       wakeable.then(retry, retry);
     }
   });
@@ -25322,9 +28599,13 @@ function isSuspenseBoundaryBeingHidden(current, finishedWork) {
   return false;
 }
 function commitMutationEffects(root, finishedWork, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
   setCurrentFiber(finishedWork);
   commitMutationEffectsOnFiber(finishedWork, root);
   setCurrentFiber(finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
 }
 
 function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
@@ -25391,7 +28672,20 @@ function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
         // 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);
+          }
+
+          recordLayoutEffectDuration(finishedWork);
+        } else {
           try {
             commitHookEffectListUnmount(
               Layout | HasEffect,
@@ -25890,8 +29184,12 @@ function commitReconciliationEffects(finishedWork) {
 }
 
 function commitLayoutEffects(finishedWork, root, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
   var current = finishedWork.alternate;
   commitLayoutEffectOnFiber(root, current, finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
 }
 
 function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
@@ -25918,7 +29216,18 @@ function disappearLayoutEffects(finishedWork) {
     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);
       }
 
@@ -26072,6 +29381,10 @@ function reappearLayoutEffects(
         includeWorkInProgressEffects
       ); // TODO: Figure out how Profiler updates should work with Offscreen
 
+      if (includeWorkInProgressEffects && flags & Update) {
+        commitProfilerUpdate(finishedWork, current);
+      }
+
       break;
     }
 
@@ -26148,7 +29461,17 @@ function recursivelyTraverseReappearLayoutEffects(
 }
 
 function commitHookPassiveMountEffects(finishedWork, hookFlags) {
-  {
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
+
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+
+    recordPassiveEffectDuration(finishedWork);
+  } else {
     try {
       commitHookEffectListMount(hookFlags, finishedWork);
     } catch (error) {
@@ -26191,6 +29514,71 @@ function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
       }
     }
   }
+
+  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();
+            }
+
+            instance._transitions.add(transition);
+          });
+        }
+
+        var markerInstances = queue.markerInstances;
+
+        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 (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 (instance._pendingMarkers === null) {
+                    instance._pendingMarkers = new Set();
+                  }
+
+                  instance._pendingMarkers.add(markerInstance);
+                }
+              });
+            }
+          });
+        }
+      }
+
+      finishedWork.updateQueue = null;
+    }
+
+    commitTransitionProgress(finishedWork); // TODO: Refactor this into an if/else branch
+
+    if (!isHidden) {
+      instance._transitions = null;
+      instance._pendingMarkers = null;
+    }
+  }
 }
 
 function commitCachePassiveMountEffect(current, finishedWork) {
@@ -26217,6 +29605,25 @@ function commitCachePassiveMountEffect(current, finishedWork) {
   }
 }
 
+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,
@@ -26319,12 +29726,54 @@ function commitPassiveMountOnFiber(
             }
           }
         }
+
+        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 (pendingBoundaries === null || pendingBoundaries.size === 0) {
+              if (markerInstance.aborts === null) {
+                addTransitionCompleteCallbackToPendingTransition(transition);
+              }
+
+              incompleteTransitions.delete(transition);
+            }
+          });
+          clearTransitionsForLanes(finishedRoot, committedLanes);
+        }
       }
 
       break;
     }
 
     case LegacyHiddenComponent: {
+      {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
+
+        if (flags & Passive$1) {
+          var current = finishedWork.alternate;
+          var instance = finishedWork.stateNode;
+          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
+        }
+      }
+
       break;
     }
 
@@ -26396,7 +29845,7 @@ function commitPassiveMountOnFiber(
 
       if (flags & Passive$1) {
         var _current = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(_current, finishedWork);
+        commitOffscreenPassiveMountEffects(_current, finishedWork, _instance3);
       }
 
       break;
@@ -26419,7 +29868,22 @@ function commitPassiveMountOnFiber(
       break;
     }
 
-    case TracingMarkerComponent:
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
+
+        if (flags & Passive$1) {
+          commitTracingMarkerPassiveMountEffect(finishedWork);
+        }
+
+        break;
+      } // Intentional fallthrough to next branch
+    }
     // eslint-disable-next-line-no-fallthrough
 
     default: {
@@ -26499,6 +29963,23 @@ function reconnectPassiveEffects(
     // }
 
     case LegacyHiddenComponent: {
+      {
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+
+        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);
+        }
+      }
+
       break;
     }
 
@@ -26562,7 +30043,7 @@ function reconnectPassiveEffects(
       if (includeWorkInProgressEffects && flags & Passive$1) {
         // TODO: Pass `current` as argument to this function
         var _current3 = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(_current3, finishedWork);
+        commitOffscreenPassiveMountEffects(_current3, finishedWork, _instance4);
       }
 
       break;
@@ -26586,7 +30067,23 @@ function reconnectPassiveEffects(
       break;
     }
 
-    case TracingMarkerComponent:
+    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
 
     default: {
@@ -26644,7 +30141,8 @@ function commitAtomicPassiveEffects(
       if (flags & Passive$1) {
         // TODO: Pass `current` as argument to this function
         var current = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(current, finishedWork);
+        var instance = finishedWork.stateNode;
+        commitOffscreenPassiveMountEffects(current, finishedWork, instance);
       }
 
       break;
@@ -26711,7 +30209,15 @@ function commitHookPassiveUnmountEffects(
   nearestMountedAncestor,
   hookFlags
 ) {
-  {
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
+    commitHookEffectListUnmount(
+      hookFlags,
+      finishedWork,
+      nearestMountedAncestor
+    );
+    recordPassiveEffectDuration(finishedWork);
+  } else {
     commitHookEffectListUnmount(
       hookFlags,
       finishedWork,
@@ -26971,6 +30477,43 @@ function commitPassiveUnmountInsideDeletedTreeOnFiber(
     }
 
     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
+              );
+            }
+          }
+        }
+      }
+
       break;
     }
 
@@ -26982,6 +30525,40 @@ function commitPassiveUnmountInsideDeletedTreeOnFiber(
 
       break;
     }
+
+    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;
+    }
   }
 }
 
@@ -27645,6 +31222,24 @@ function isConcurrentActEnvironment() {
   }
 }
 
+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);
+      }
+
+      postPaintCallbackScheduled = false;
+      callbacks = [];
+    });
+  }
+}
+
 var ceil = Math.ceil;
 var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
 var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
@@ -27732,9 +31327,157 @@ var workInProgressRootRenderTargetTime = Infinity; // How long a render is suppo
 
 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
+      };
+    }
+
+    if (currentPendingTransitionCallbacks.transitionStart === null) {
+      currentPendingTransitionCallbacks.transitionStart = [];
+    }
+
+    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
+      };
+    }
+
+    if (currentPendingTransitionCallbacks.markerProgress === null) {
+      currentPendingTransitionCallbacks.markerProgress = new Map();
+    }
+
+    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 (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 (currentPendingTransitionCallbacks.markerComplete === null) {
+      currentPendingTransitionCallbacks.markerComplete = new Map();
+    }
+
+    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 (currentPendingTransitionCallbacks.transitionProgress === null) {
+      currentPendingTransitionCallbacks.transitionProgress = new Map();
+    }
+
+    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
+      };
+    }
+
+    if (currentPendingTransitionCallbacks.transitionComplete === null) {
+      currentPendingTransitionCallbacks.transitionComplete = [];
+    }
+
+    currentPendingTransitionCallbacks.transitionComplete.push(transition);
+  }
+}
 
 function resetRenderTimer() {
-  workInProgressRootRenderTargetTime = now() + RENDER_TIMEOUT_MS;
+  workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
 }
 
 function getRenderTargetTime() {
@@ -27743,9 +31486,13 @@ function getRenderTargetTime() {
 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
 
@@ -27772,7 +31519,7 @@ function getWorkInProgressRootRenderLanes() {
 function requestEventTime() {
   if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
     // We're inside React, so it's fine to read the actual time.
-    return now();
+    return now$1();
   } // We're not inside React, so we may be in the middle of a browser event.
 
   if (currentEventTime !== NoTimestamp) {
@@ -27780,7 +31527,7 @@ function requestEventTime() {
     return currentEventTime;
   } // This is the first update since React yielded. Compute a new start time.
 
-  currentEventTime = now();
+  currentEventTime = now$1();
   return currentEventTime;
 }
 function requestUpdateLane(fiber) {
@@ -27790,6 +31537,7 @@ function requestUpdateLane(fiber) {
   if ((mode & ConcurrentMode) === NoMode) {
     return SyncLane;
   } else if (
+    !deferRenderPhaseUpdateToNextBatch &&
     (executionContext & RenderContext) !== NoContext &&
     workInProgressRootRenderLanes !== NoLanes
   ) {
@@ -27903,15 +31651,64 @@ function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
     // 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);
+      }
+    }
+
     warnIfUpdatesNotWrappedWithActDEV(fiber);
 
+    if (enableProfilerNestedUpdateScheduledHook) {
+      if (
+        (executionContext & CommitContext) !== NoContext &&
+        root === rootCommittingMutationOrLayoutEffects
+      ) {
+        if (fiber.mode & ProfileMode) {
+          var current = fiber;
+
+          while (current !== null) {
+            if (current.tag === Profiler) {
+              var _current$memoizedProp = current.memoizedProps,
+                id = _current$memoizedProp.id,
+                onNestedUpdateScheduled =
+                  _current$memoizedProp.onNestedUpdateScheduled;
+
+              if (typeof onNestedUpdateScheduled === "function") {
+                onNestedUpdateScheduled(id);
+              }
+            }
+
+            current = current.return;
+          }
+        }
+      }
+    }
+
+    if (enableTransitionTracing) {
+      var transition = ReactCurrentBatchConfig$1.transition;
+
+      if (transition !== null && transition.name != null) {
+        if (transition.startTime === -1) {
+          transition.startTime = now$1();
+        }
+
+        addTransitionToLanesMap(root, transition, lane);
+      }
+    }
+
     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 ((executionContext & RenderContext) === NoContext) {
+      if (
+        deferRenderPhaseUpdateToNextBatch ||
+        (executionContext & RenderContext) === NoContext
+      ) {
         workInProgressRootInterleavedUpdatedLanes = mergeLanes(
           workInProgressRootInterleavedUpdatedLanes,
           lane
@@ -27968,6 +31765,8 @@ function isUnsafeClassRenderPhaseUpdate(fiber) {
   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
@@ -28122,6 +31921,9 @@ function ensureRootIsScheduled(root, currentTime) {
 // goes through Scheduler.
 
 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.
 
   currentEventTime = NoTimestamp;
@@ -28165,7 +31967,7 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
   var shouldTimeSlice =
     !includesBlockingLane(root, lanes) &&
     !includesExpiredLane(root, lanes) &&
-    !didTimeout;
+    (disableSchedulerTimeoutInWorkLoop || !didTimeout);
   var exitStatus = shouldTimeSlice
     ? renderRootConcurrent(root, lanes)
     : renderRootSync(root, lanes);
@@ -28196,7 +31998,7 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
       var fatalError = workInProgressRootFatalError;
       prepareFreshStack(root, NoLanes);
       markRootSuspended(root, lanes);
-      ensureRootIsScheduled(root, now());
+      ensureRootIsScheduled(root, now$1());
       throw fatalError;
     }
 
@@ -28246,7 +32048,7 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
           var _fatalError = workInProgressRootFatalError;
           prepareFreshStack(root, NoLanes);
           markRootSuspended(root, lanes);
-          ensureRootIsScheduled(root, now());
+          ensureRootIsScheduled(root, now$1());
           throw _fatalError;
         } // FIXME: Need to check for RootDidNotComplete again. The factoring here
         // isn't ideal.
@@ -28259,7 +32061,7 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
     }
   }
 
-  ensureRootIsScheduled(root, now());
+  ensureRootIsScheduled(root, now$1());
 
   if (root.callbackNode === originalCallbackNode) {
     // The task node scheduled for this root is the same one that's
@@ -28388,7 +32190,7 @@ function finishConcurrentRender(root, exitStatus, lanes) {
         // 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(); // Don't bother with a very short suspense time.
+          globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(); // Don't bother with a very short suspense time.
 
         if (msUntilTimeout > 10) {
           var nextLanes = getNextLanes(root, NoLanes);
@@ -28440,7 +32242,7 @@ function finishConcurrentRender(root, exitStatus, lanes) {
         // Consider removing.
         var mostRecentEventTime = getMostRecentEventTime(root, lanes);
         var eventTimeMs = mostRecentEventTime;
-        var timeElapsedMs = now() - eventTimeMs;
+        var timeElapsedMs = now$1() - eventTimeMs;
 
         var _msUntilTimeout = jnd(timeElapsedMs) - timeElapsedMs; // Don't bother with a very short suspense time.
 
@@ -28561,6 +32363,10 @@ function markRootSuspended(root, suspendedLanes) {
 // through Scheduler
 
 function performSyncWorkOnRoot(root) {
+  {
+    syncNestedUpdateFlag();
+  }
+
   if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
     throw new Error("Should not already be working.");
   }
@@ -28570,7 +32376,7 @@ function performSyncWorkOnRoot(root) {
 
   if (!includesSyncLane(lanes)) {
     // There's no remaining sync work left.
-    ensureRootIsScheduled(root, now());
+    ensureRootIsScheduled(root, now$1());
     return null;
   }
 
@@ -28601,7 +32407,7 @@ function performSyncWorkOnRoot(root) {
     var fatalError = workInProgressRootFatalError;
     prepareFreshStack(root, NoLanes);
     markRootSuspended(root, lanes);
-    ensureRootIsScheduled(root, now());
+    ensureRootIsScheduled(root, now$1());
     throw fatalError;
   }
 
@@ -28610,7 +32416,7 @@ function performSyncWorkOnRoot(root) {
     // cases where need to exit the current render without producing a
     // consistent tree or committing.
     markRootSuspended(root, lanes);
-    ensureRootIsScheduled(root, now());
+    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.
@@ -28625,14 +32431,14 @@ function performSyncWorkOnRoot(root) {
   ); // Before exiting, make sure there's a callback scheduled for the next
   // pending level.
 
-  ensureRootIsScheduled(root, now());
+  ensureRootIsScheduled(root, now$1());
   return null;
 }
 
 function flushRoot(root, lanes) {
   if (lanes !== NoLanes) {
     markRootEntangled(root, mergeLanes(lanes, SyncLane));
-    ensureRootIsScheduled(root, now());
+    ensureRootIsScheduled(root, now$1());
 
     if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
       resetRenderTimer();
@@ -28640,6 +32446,9 @@ function flushRoot(root, lanes) {
     }
   }
 }
+function getExecutionContext() {
+  return executionContext;
+}
 function batchedUpdates$1(fn, a) {
   var prevExecutionContext = executionContext;
   executionContext |= BatchedContext;
@@ -28723,6 +32532,10 @@ function isAlreadyRendering() {
   // 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;
@@ -28886,6 +32699,41 @@ function handleThrow(root, thrownValue) {
     workInProgressRootFatalError = thrownValue;
     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);
+  }
+
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+
+    switch (workInProgressSuspendedReason) {
+      case SuspendedOnError: {
+        markComponentErrored(
+          erroredWork,
+          thrownValue,
+          workInProgressRootRenderLanes
+        );
+        break;
+      }
+
+      case SuspendedOnData:
+      case SuspendedOnImmediate:
+      case SuspendedOnDeprecatedThrowPromise:
+      case SuspendedAndReadyToContinue: {
+        var wakeable = thrownValue;
+        markComponentSuspended(
+          erroredWork,
+          wakeable,
+          workInProgressRootRenderLanes
+        );
+        break;
+      }
+    }
+  }
 }
 
 function shouldAttemptToSuspendUntilDataResolves() {
@@ -28963,7 +32811,7 @@ function popCacheDispatcher(prevCacheDispatcher) {
 }
 
 function markCommitTimeOfFallback() {
-  globalMostRecentFallbackTime = now();
+  globalMostRecentFallbackTime = now$1();
 }
 function markSkippedUpdateLanes(lane) {
   workInProgressRootSkippedLanes = mergeLanes(
@@ -29027,10 +32875,36 @@ function renderRootSync(root, lanes) {
   // and prepare a fresh one. Otherwise we'll continue where we left off.
 
   if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    workInProgressTransitions = getTransitionsForLanes();
+    {
+      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.
+
+        movePendingFibersToMemoized(root, lanes);
+      }
+    }
+
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
     prepareFreshStack(root, lanes);
   }
 
+  {
+    if (enableDebugTracing) {
+      logRenderStarted(lanes);
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markRenderStarted(lanes);
+  }
+
   outer: do {
     try {
       if (
@@ -29088,6 +32962,16 @@ function renderRootSync(root, lanes) {
     );
   }
 
+  {
+    if (enableDebugTracing) {
+      logRenderStopped();
+    }
+  }
+
+  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.
 
@@ -29112,11 +32996,37 @@ function renderRootConcurrent(root, lanes) {
   // and prepare a fresh one. Otherwise we'll continue where we left off.
 
   if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    workInProgressTransitions = getTransitionsForLanes();
+    {
+      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.
+
+        movePendingFibersToMemoized(root, lanes);
+      }
+    }
+
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
     resetRenderTimer();
     prepareFreshStack(root, lanes);
   }
 
+  {
+    if (enableDebugTracing) {
+      logRenderStarted(lanes);
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markRenderStarted(lanes);
+  }
+
   outer: do {
     try {
       if (
@@ -29165,7 +33075,7 @@ function renderRootConcurrent(root, lanes) {
               // currently working on a different root, so that we resume
               // rendering later.
 
-              ensureRootIsScheduled(root, now());
+              ensureRootIsScheduled(root, now$1());
             };
 
             thenable.then(onResolution, onResolution);
@@ -29248,9 +33158,25 @@ function renderRootConcurrent(root, lanes) {
   popCacheDispatcher(prevCacheDispatcher);
   executionContext = prevExecutionContext;
 
+  {
+    if (enableDebugTracing) {
+      logRenderStopped();
+    }
+  } // Check if the tree has completed.
+
   if (workInProgress !== null) {
+    // Still work remaining.
+    if (enableSchedulingProfiler) {
+      markRenderYielded();
+    }
+
     return RootInProgress;
   } else {
+    // Completed the tree.
+    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.
 
@@ -29277,7 +33203,11 @@ function performUnitOfWork(unitOfWork) {
   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);
   }
 
@@ -29302,6 +33232,11 @@ function replaySuspendedUnitOfWork(unitOfWork) {
   setCurrentFiber(unitOfWork);
   var next;
   setCurrentFiber(unitOfWork);
+  var isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
+
+  if (isProfilingMode) {
+    startProfilerTimer(unitOfWork);
+  }
 
   switch (unitOfWork.tag) {
     case IndeterminateComponent: {
@@ -29364,6 +33299,10 @@ function replaySuspendedUnitOfWork(unitOfWork) {
       break;
     }
   }
+
+  if (isProfilingMode) {
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } // The begin phase finished successfully without suspending. Return to the
   // normal work loop.
 
   resetCurrentFiber();
@@ -29443,8 +33382,13 @@ function completeUnitOfWork(unitOfWork) {
       setCurrentFiber(completedWork);
       var next = void 0;
 
-      {
+      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.
+
+        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
       }
 
       resetCurrentFiber();
@@ -29470,6 +33414,22 @@ function completeUnitOfWork(unitOfWork) {
         return;
       }
 
+      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;
+        }
+
+        completedWork.actualDuration = actualDuration;
+      }
+
       if (returnFiber !== null) {
         // Mark the parent fiber as incomplete and clear its subtree flags.
         returnFiber.flags |= Incomplete;
@@ -29550,7 +33510,27 @@ function commitRootImpl(
   var finishedWork = root.finishedWork;
   var lanes = root.finishedLanes;
 
+  {
+    if (enableDebugTracing) {
+      logCommitStarted(lanes);
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markCommitStarted(lanes);
+  }
+
   if (finishedWork === null) {
+    {
+      if (enableDebugTracing) {
+        logCommitStopped();
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markCommitStopped();
+    }
+
     return null;
   } else {
     {
@@ -29653,7 +33633,19 @@ function commitRootImpl(
       finishedWork
     );
 
-    commitMutationEffects(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 (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 (shouldFireAfterActiveInstanceBlur) {
@@ -29667,8 +33659,34 @@ function commitRootImpl(
     // 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);
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markLayoutEffectsStarted(lanes);
+    }
+
+    commitLayoutEffects(finishedWork, root, lanes);
+
+    {
+      if (enableDebugTracing) {
+        logLayoutEffectsStopped();
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markLayoutEffectsStopped();
+    }
 
-    commitLayoutEffects(finishedWork, root);
+    if (enableProfilerNestedUpdateScheduledHook) {
+      rootCommittingMutationOrLayoutEffects = null;
+    } // Tell Scheduler to yield at the end of the frame, so the browser has an
     // opportunity to paint.
 
     requestPaint();
@@ -29679,6 +33697,12 @@ function commitRootImpl(
   } 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();
+    }
   }
 
   var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;
@@ -29725,12 +33749,18 @@ function commitRootImpl(
 
   onCommitRoot$1(finishedWork.stateNode, renderPriorityLevel);
 
+  {
+    if (isDevToolsPresent) {
+      root.memoizedUpdaters.clear();
+    }
+  }
+
   {
     onCommitRoot();
   } // Always call this before exiting `commitRoot`, to ensure that any
   // additional work on this root is scheduled.
 
-  ensureRootIsScheduled(root, now());
+  ensureRootIsScheduled(root, now$1());
 
   if (recoverableErrors !== null) {
     // There were errors during this render, but recovered from them without
@@ -29768,6 +33798,9 @@ function commitRootImpl(
   remainingLanes = root.pendingLanes;
 
   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 (root === rootWithNestedUpdates) {
@@ -29782,6 +33815,48 @@ function commitRootImpl(
 
   flushSyncCallbacks();
 
+  {
+    if (enableDebugTracing) {
+      logCommitStopped();
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markCommitStopped();
+  }
+
+  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 (prevRootTransitionCallbacks !== null) {
+      schedulePostPaintCallback(function (endTime) {
+        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+
+        if (prevPendingTransitionCallbacks !== null) {
+          currentPendingTransitionCallbacks = null;
+          scheduleCallback(IdlePriority, function () {
+            processTransitionCallbacks(
+              prevPendingTransitionCallbacks,
+              endTime,
+              prevRootTransitionCallbacks
+            );
+          });
+        } else {
+          currentEndTime = endTime;
+        }
+      });
+    }
+  }
+
   return null;
 }
 
@@ -29862,6 +33937,19 @@ function flushPassiveEffects() {
 
   return false;
 }
+function enqueuePendingPassiveProfilerEffect(fiber) {
+  {
+    pendingPassiveProfilerEffects.push(fiber);
+
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      scheduleCallback(NormalPriority$1, function () {
+        flushPassiveEffects();
+        return null;
+      });
+    }
+  }
+}
 
 function flushPassiveEffectsImpl() {
   if (rootWithPendingPassiveEffects === null) {
@@ -29885,6 +33973,14 @@ function flushPassiveEffectsImpl() {
   {
     isFlushingPassiveEffects = true;
     didScheduleUpdateDuringPassiveEffects = false;
+
+    if (enableDebugTracing) {
+      logPassiveEffectsStarted(lanes);
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markPassiveEffectsStarted(lanes);
   }
 
   var prevExecutionContext = executionContext;
@@ -29892,6 +33988,26 @@ function flushPassiveEffectsImpl() {
   commitPassiveUnmountEffects(root.current);
   commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
 
+  {
+    var profilerEffects = pendingPassiveProfilerEffects;
+    pendingPassiveProfilerEffects = [];
+
+    for (var i = 0; i < profilerEffects.length; i++) {
+      var fiber = profilerEffects[i];
+      commitPassiveEffectDurations(root, fiber);
+    }
+  }
+
+  {
+    if (enableDebugTracing) {
+      logPassiveEffectsStopped();
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markPassiveEffectsStopped();
+  }
+
   {
     commitDoubleInvokeEffectsInDEV(root, true);
   }
@@ -29899,6 +34015,28 @@ function flushPassiveEffectsImpl() {
   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
+        );
+      });
+    }
+  }
+
   {
     // If additional passive effects were scheduled, increment a counter. If this
     // exceeds the limit, we'll fire a warning.
@@ -29919,6 +34057,12 @@ function flushPassiveEffectsImpl() {
 
   onPostCommitRoot(root);
 
+  {
+    var stateNode = root.current.stateNode;
+    stateNode.effectDuration = 0;
+    stateNode.passiveEffectDuration = 0;
+  }
+
   return true;
 }
 
@@ -29972,8 +34116,10 @@ function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error$1) {
 
   var fiber = null;
 
-  {
+  if (skipUnmountedBoundaries) {
     fiber = nearestMountedAncestor;
+  } else {
+    fiber = sourceFiber.return;
   }
 
   while (fiber !== null) {
@@ -30057,6 +34203,13 @@ function attachPingListener(root, wakeable, lanes) {
     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);
+      }
+    }
+
     wakeable.then(ping, ping);
   }
 }
@@ -30089,7 +34242,7 @@ function pingSuspendedRoot(root, wakeable, pingedLanes) {
       workInProgressRootExitStatus === RootSuspendedWithDelay ||
       (workInProgressRootExitStatus === RootSuspended &&
         includesOnlyRetries(workInProgressRootRenderLanes) &&
-        now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS)
+        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.
@@ -30358,7 +34511,78 @@ function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
 }
 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
+
+      resetSuspendedWorkLoopOnUnwind();
+      unwindInterruptedWork(current, unitOfWork); // Restore the original properties of the fiber.
+
+      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.
+
+      throw originalError;
+    }
+  };
+} else {
   beginWork = beginWork$1;
 }
 
@@ -30417,6 +34641,19 @@ function warnAboutRenderPhaseUpdatesInDEV(fiber) {
     }
   }
 }
+
+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]
 
 function scheduleCallback(priorityLevel, callback) {
@@ -31030,6 +35267,32 @@ function FiberNode(tag, pendingProps, key, mode) {
   this.childLanes = NoLanes;
   this.alternate = 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).
+
+    this.actualDuration = 0;
+    this.actualStartTime = -1;
+    this.selfBaseDuration = 0;
+    this.treeBaseDuration = 0;
+  }
+
   {
     // This isn't directly used but is handy for debugging internals:
     this._debugSource = null;
@@ -31128,6 +35391,15 @@ function createWorkInProgress(current, pendingProps) {
 
     workInProgress.subtreeFlags = NoFlags$1;
     workInProgress.deletions = null;
+
+    {
+      // 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.
 
@@ -31154,6 +35426,11 @@ function createWorkInProgress(current, pendingProps) {
   workInProgress.ref = current.ref;
   workInProgress.refCleanup = current.refCleanup;
 
+  {
+    workInProgress.selfBaseDuration = current.selfBaseDuration;
+    workInProgress.treeBaseDuration = current.treeBaseDuration;
+  }
+
   {
     workInProgress._debugNeedsRemount = current._debugNeedsRemount;
 
@@ -31201,6 +35478,13 @@ function resetWorkInProgress(workInProgress, renderLanes) {
     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;
@@ -31223,6 +35507,13 @@ function resetWorkInProgress(workInProgress, renderLanes) {
             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 workInProgress;
@@ -31251,6 +35542,13 @@ function createHostRootFiber(
     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;
+  }
+
   return createFiber(HostRoot, null, null, mode);
 }
 function createFiberFromTypeAndProps(
@@ -31314,7 +35612,9 @@ function createFiberFromTypeAndProps(
       case REACT_OFFSCREEN_TYPE:
         return createFiberFromOffscreen(pendingProps, mode, lanes, key);
 
-      case REACT_LEGACY_HIDDEN_TYPE:
+      case REACT_LEGACY_HIDDEN_TYPE: {
+        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
+      }
 
       // eslint-disable-next-line no-fallthrough
 
@@ -31331,10 +35631,18 @@ function createFiberFromTypeAndProps(
       // eslint-disable-next-line no-fallthrough
 
       case REACT_TRACING_MARKER_TYPE:
+        if (enableTransitionTracing) {
+          return createFiberFromTracingMarker(pendingProps, mode, lanes, key);
+        }
 
       // eslint-disable-next-line no-fallthrough
 
       case REACT_DEBUG_TRACING_MODE_TYPE:
+        if (enableDebugTracing) {
+          fiberTag = Mode;
+          mode |= DebugTracingMode;
+          break;
+        }
 
       // eslint-disable-next-line no-fallthrough
 
@@ -31466,6 +35774,13 @@ function createFiberFromProfiler(pendingProps, mode, lanes, key) {
   fiber.elementType = REACT_PROFILER_TYPE;
   fiber.lanes = lanes;
 
+  {
+    fiber.stateNode = {
+      effectDuration: 0,
+      passiveEffectDuration: 0
+    };
+  }
+
   return fiber;
 }
 
@@ -31502,12 +35817,49 @@ function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
   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;
@@ -31536,6 +35888,55 @@ function createFiberFromPortal(portal, mode, lanes) {
   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 FiberRootNode(
   containerInfo, // $FlowFixMe[missing-local-annot]
   tag,
@@ -31584,6 +35985,29 @@ function FiberRootNode(
 
   this.incompleteTransitions = new Map();
 
+  if (enableTransitionTracing) {
+    this.transitionCallbacks = null;
+    var transitionLanesMap = (this.transitionLanes = []);
+
+    for (var i = 0; i < TotalLanes; i++) {
+      transitionLanesMap.push(null);
+    }
+  }
+
+  {
+    this.effectDuration = 0;
+    this.passiveEffectDuration = 0;
+  }
+
+  {
+    this.memoizedUpdaters = new Set();
+    var pendingUpdatersLaneMap = (this.pendingUpdatersLaneMap = []);
+
+    for (var _i = 0; _i < TotalLanes; _i++) {
+      pendingUpdatersLaneMap.push(new Set());
+    }
+  }
+
   {
     switch (tag) {
       case ConcurrentRoot:
@@ -31624,6 +36048,10 @@ function createFiberRoot(
   {
     root.hydrationCallbacks = hydrationCallbacks;
   }
+
+  if (enableTransitionTracing) {
+    root.transitionCallbacks = transitionCallbacks;
+  } // Cyclic construction. This cheats the type system right now because
   // stateNode is any.
 
   var uninitializedFiber = createHostRootFiber(
@@ -31658,7 +36086,7 @@ function createFiberRoot(
   return root;
 }
 
-var ReactVersion = "18.3.0-www-classic-87f4bed4";
+var ReactVersion = "18.3.0-www-classic-16b66e58";
 
 function createPortal$1(
   children,
@@ -31802,7 +36230,8 @@ function createContainer(
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   );
 }
 function createHydrationContainer(
@@ -31827,7 +36256,8 @@ function createHydrationContainer(
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   ); // TODO: Move this to FiberRoot constructor
 
   root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
@@ -31855,6 +36285,10 @@ function updateContainer(element, container, parentComponent, callback) {
   var current$1 = container.current;
   var lane = requestUpdateLane(current$1);
 
+  if (enableSchedulingProfiler) {
+    markRenderScheduled(lane);
+  }
+
   var context = getContextForSubtree(parentComponent);
 
   if (container.context === null) {
@@ -31977,6 +36411,26 @@ function markRetryLaneIfNotHydrated(fiber, retryLane) {
     markRetryLaneImpl(alternate, retryLane);
   }
 }
+
+function attemptDiscreteHydration$1(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;
+  }
+
+  var lane = SyncLane;
+  var root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
 function attemptContinuousHydration$1(fiber) {
   if (fiber.tag !== SuspenseComponent) {
     // We ignore HostRoots here because we can't increase
@@ -32413,6 +36867,7 @@ function createRoot$1(container, options) {
   var concurrentUpdatesByDefaultOverride = false;
   var identifierPrefix = "";
   var onRecoverableError = defaultOnRecoverableError;
+  var transitionCallbacks = null;
 
   if (options !== null && options !== undefined) {
     {
@@ -32452,6 +36907,10 @@ function createRoot$1(container, options) {
     if (options.onRecoverableError !== undefined) {
       onRecoverableError = options.onRecoverableError;
     }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
   }
 
   var root = createContainer(
@@ -32461,7 +36920,8 @@ function createRoot$1(container, options) {
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   );
   markContainerAsRoot(root.current, container);
 
@@ -32512,6 +36972,7 @@ function hydrateRoot$1(container, initialChildren, options) {
   var concurrentUpdatesByDefaultOverride = false;
   var identifierPrefix = "";
   var onRecoverableError = defaultOnRecoverableError;
+  var transitionCallbacks = null;
 
   if (options !== null && options !== undefined) {
     if (options.unstable_strictMode === true) {
@@ -32529,6 +36990,10 @@ function hydrateRoot$1(container, initialChildren, options) {
     if (options.onRecoverableError !== undefined) {
       onRecoverableError = options.onRecoverableError;
     }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
   }
 
   var root = createHydrationContainer(
@@ -32540,7 +37005,8 @@ function hydrateRoot$1(container, initialChildren, options) {
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   );
   markContainerAsRoot(root.current, container);
 
@@ -32566,7 +37032,8 @@ function isValidContainer(node) {
     (node.nodeType === ELEMENT_NODE ||
       node.nodeType === DOCUMENT_NODE ||
       node.nodeType === DOCUMENT_FRAGMENT_NODE ||
-      !disableCommentsAsDOMContainers)
+      (node.nodeType === COMMENT_NODE &&
+        node.nodeValue === " react-mount-point-unstable "))
   );
 } // TODO: Remove this function which also includes comment nodes.
 // We only use it in places that are currently more relaxed.
@@ -32681,7 +37148,8 @@ function legacyCreateRootFromDOMContainer(
       false, // isStrictMode
       false, // concurrentUpdatesByDefaultOverride,
       "", // identifierPrefix
-      noopOnRecoverableError
+      noopOnRecoverableError, // TODO(luna) Support hydration later
+      null
     );
     container._reactRootContainer = root;
     markContainerAsRoot(root.current, container);
@@ -32712,7 +37180,8 @@ function legacyCreateRootFromDOMContainer(
       false, // isStrictMode
       false, // concurrentUpdatesByDefaultOverride,
       "", // identifierPrefix
-      noopOnRecoverableError
+      noopOnRecoverableError, // onRecoverableError
+      null // transitionCallbacks
     );
 
     container._reactRootContainer = _root;
@@ -33260,6 +37729,7 @@ function preinit$1() {
 }
 
 setAttemptSynchronousHydration(attemptSynchronousHydration$1);
+setAttemptDiscreteHydration(attemptDiscreteHydration$1);
 setAttemptContinuousHydration(attemptContinuousHydration$1);
 setAttemptHydrationAtCurrentPriority(attemptHydrationAtCurrentPriority$1);
 setGetCurrentUpdatePriority(getCurrentUpdatePriority$1);
@@ -34851,6 +39321,10 @@ 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$1(node) {
   return getClosestInstanceFromNode(node) || null;
 }
@@ -35784,6 +40258,13 @@ function setupIntersectionObserver(targets, callback, options) {
     }
   };
 }
+function requestPostPaintCallback(callback) {
+  localRequestAnimationFrame(function () {
+    localRequestAnimationFrame(function (time) {
+      return callback(time);
+    });
+  });
+} // -------------------
 function isHostHoistableType(type, props, hostContext) {
   var outsideHostContainerContext;
   var namespace;
@@ -37863,7 +42344,7 @@ function handleControlledInputBlur(node) {
     return;
   }
 
-  {
+  if (!disableInputAttributeSyncing) {
     // If controlled, assign the value attribute to the current value on blur
     setDefaultValue(node, "number", node.value);
   }
@@ -37902,7 +42383,13 @@ function extractEvents$4(
     }
   } else if (shouldUseClickEvent(targetNode)) {
     getTargetInstFunc = getTargetInstForClickEvent;
-  } else;
+  } else if (
+    enableCustomElementPropertySupport &&
+    targetInst &&
+    isCustomComponent(targetInst.elementType, targetInst.memoizedProps)
+  ) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  }
 
   if (getTargetInstFunc) {
     var inst = getTargetInstFunc(domEventName, targetInst);
@@ -38899,9 +43386,10 @@ function addTrappedEventListener(
     }
   }
 
-  targetContainer = isDeferredListenerForLegacyFBSupport
-    ? targetContainer.ownerDocument
-    : targetContainer;
+  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
@@ -38914,7 +43402,7 @@ function addTrappedEventListener(
   // to support legacy code patterns, it's likely they'll
   // need support for such browsers.
 
-  if (isDeferredListenerForLegacyFBSupport) {
+  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
     var originalListener = listener; // $FlowFixMe[missing-this-annot]
     // $FlowFixMe[definition-cycle]
 
@@ -39006,7 +43494,7 @@ function dispatchEventForPluginEventSystem(
     // time event listener so we can defer the event.
 
     if (
-      // If our event flags match the required flags for entering
+      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
@@ -39478,6 +43966,10 @@ function setAttemptSynchronousHydration(fn) {
 function attemptSynchronousHydration(fiber) {
   _attemptSynchronousHydration(fiber);
 }
+var attemptDiscreteHydration;
+function setAttemptDiscreteHydration(fn) {
+  attemptDiscreteHydration = fn;
+}
 var attemptContinuousHydration;
 function setAttemptContinuousHydration(fn) {
   attemptContinuousHydration = fn;
@@ -39509,6 +44001,9 @@ var queuedPointers = new Map();
 var queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
 
 var queuedExplicitHydrationTargets = [];
+function hasQueuedDiscreteEvents() {
+  return queuedDiscreteEvents.length > 0;
+}
 var discreteReplayableEvents = [
   "mousedown",
   "mouseup",
@@ -39559,6 +44054,53 @@ function createQueuedReplayableEvent(
   };
 }
 
+function queueDiscreteEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    return;
+  }
+
+  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);
+
+      if (fiber === null) {
+        break;
+      }
+
+      attemptSynchronousHydration(fiber);
+
+      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.
+
+        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.
+
 function clearIfContinuousEvent(domEventName, nativeEvent) {
   switch (domEventName) {
     case "focusin":
@@ -39816,7 +44358,7 @@ function attemptReplayContinuousQueuedEvent(queuedEvent) {
     );
 
     if (nextBlockedOn === null) {
-      {
+      if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
         var nativeEvent = queuedEvent.nativeEvent;
         var nativeEventClone = new nativeEvent.constructor(
           nativeEvent.type,
@@ -39825,6 +44367,16 @@ function attemptReplayContinuousQueuedEvent(queuedEvent) {
         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.
@@ -39853,6 +44405,63 @@ function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
 function replayUnblockedEvents() {
   hasScheduledReplayAttempt = false;
 
+  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    // First replay discrete events.
+    while (queuedDiscreteEvents.length > 0) {
+      var nextDiscreteEvent = queuedDiscreteEvents[0];
+
+      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);
+        }
+
+        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;
   }
@@ -40037,16 +44646,116 @@ function dispatchEvent(
     return;
   }
 
-  {
+  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);
+    }
+
+    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;
+    } // We need to clear only if we didn't queue because
+    // queueing is accumulative.
+
+    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.
+
+  dispatchEventForPluginEventSystem(
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    null,
+    targetContainer
+  );
+}
+
 function dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
   domEventName,
   eventSystemFlags,
diff --git a/compiled/facebook-www/ReactDOMTesting-dev.modern.js b/compiled/facebook-www/ReactDOMTesting-dev.modern.js
index cd5a97a05bb50..6d2785e09d3e3 100644
--- a/compiled/facebook-www/ReactDOMTesting-dev.modern.js
+++ b/compiled/facebook-www/ReactDOMTesting-dev.modern.js
@@ -29,9 +29,16 @@ var Internals = {
 
 // This refers to a WWW module.
 var warningWWW = require("warning");
+
+var suppressWarning = false;
+function setSuppressWarning(newSuppressWarning) {
+  {
+    suppressWarning = newSuppressWarning;
+  }
+}
 function warn(format) {
   {
-    {
+    if (!suppressWarning) {
       for (
         var _len = arguments.length,
           args = new Array(_len > 1 ? _len - 1 : 0),
@@ -48,7 +55,7 @@ function warn(format) {
 }
 function error(format) {
   {
-    {
+    if (!suppressWarning) {
       for (
         var _len2 = arguments.length,
           args = new Array(_len2 > 1 ? _len2 - 1 : 0),
@@ -118,16 +125,45 @@ var TracingMarkerComponent = 25;
 var HostHoistable = 26;
 var HostSingleton = 27;
 
-var debugRenderPhaseSideEffectsForStrictMode = false;
-var enableSchedulingProfiler = false;
-var enableProfilerTimer = false;
-var disableCommentsAsDOMContainers = true;
-var enableSuspenseCallback = true;
-var enableClientRenderFallbackOnTextMismatch = true;
+// Re-export dynamic flags from the www version.
+var dynamicFeatureFlags = require("ReactFeatureFlags");
+
+var disableInputAttributeSyncing =
+    dynamicFeatureFlags.disableInputAttributeSyncing,
+  enableTrustedTypesIntegration =
+    dynamicFeatureFlags.enableTrustedTypesIntegration,
+  replayFailedUnitOfWorkWithInvokeGuardedCallback =
+    dynamicFeatureFlags.replayFailedUnitOfWorkWithInvokeGuardedCallback,
+  enableFilterEmptyStringAttributesDOM =
+    dynamicFeatureFlags.enableFilterEmptyStringAttributesDOM,
+  enableLegacyFBSupport = dynamicFeatureFlags.enableLegacyFBSupport,
+  deferRenderPhaseUpdateToNextBatch =
+    dynamicFeatureFlags.deferRenderPhaseUpdateToNextBatch,
+  enableDebugTracing = dynamicFeatureFlags.enableDebugTracing,
+  skipUnmountedBoundaries = dynamicFeatureFlags.skipUnmountedBoundaries,
+  enableUseRefAccessWarning = dynamicFeatureFlags.enableUseRefAccessWarning,
+  disableNativeComponentFrames =
+    dynamicFeatureFlags.disableNativeComponentFrames,
+  disableSchedulerTimeoutInWorkLoop =
+    dynamicFeatureFlags.disableSchedulerTimeoutInWorkLoop,
+  enableLazyContextPropagation =
+    dynamicFeatureFlags.enableLazyContextPropagation,
+  enableUnifiedSyncLane = dynamicFeatureFlags.enableUnifiedSyncLane,
+  enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay =
+    dynamicFeatureFlags.enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay,
+  enableTransitionTracing = dynamicFeatureFlags.enableTransitionTracing,
+  enableCustomElementPropertySupport =
+    dynamicFeatureFlags.enableCustomElementPropertySupport; // On WWW, true is used for a new modern build.
+var enableProfilerTimer = true;
+var enableProfilerCommitHooks = true;
+var enableProfilerNestedUpdatePhase = true;
+var enableProfilerNestedUpdateScheduledHook =
+  dynamicFeatureFlags.enableProfilerNestedUpdateScheduledHook;
 var createRootStrictEffectsByDefault = false;
-var enableLazyContextPropagation = false;
-var enableLegacyHidden = false;
-var enableCustomElementPropertySupport = false;
+var enableClientRenderFallbackOnTextMismatch = false; // Logs additional User Timing API marks for use with an experimental profiling tool.
+
+var enableSchedulingProfiler = dynamicFeatureFlags.enableSchedulingProfiler; // Note: we'll want to remove this when we to userland implementation.
+var enableSuspenseCallback = true;
 
 var randomKey = Math.random().toString(36).slice(2);
 var internalInstanceKey = "__reactFiber$" + randomKey;
@@ -850,10 +886,43 @@ function shouldRemoveAttribute(
   }
 
   if (isCustomComponentTag) {
+    if (enableCustomElementPropertySupport) {
+      if (value === false) {
+        return true;
+      }
+    }
+
     return false;
   }
 
   if (propertyInfo !== null) {
+    if (enableFilterEmptyStringAttributesDOM) {
+      if (propertyInfo.removeEmptyString && value === "") {
+        {
+          if (name === "src") {
+            error(
+              'An empty string ("") was passed to the %s attribute. ' +
+                "This may cause the browser to download the whole page again over the network. " +
+                "To fix this, either do not render the element at all " +
+                "or pass null to %s instead of an empty string.",
+              name,
+              name
+            );
+          } else {
+            error(
+              'An empty string ("") was passed to the %s attribute. ' +
+                "To fix this, either do not render the element at all " +
+                "or pass null to %s instead of an empty string.",
+              name,
+              name
+            );
+          }
+        }
+
+        return true;
+      }
+    }
+
     switch (propertyInfo.type) {
       case BOOLEAN:
         return !value;
@@ -914,6 +983,10 @@ var reservedProps = [
   "style"
 ];
 
+if (enableCustomElementPropertySupport) {
+  reservedProps.push("innerText", "textContent");
+}
+
 reservedProps.forEach(function (name) {
   // $FlowFixMe[invalid-constructor] Flow no longer supports calling new on functions
   properties[name] = new PropertyInfoRecord(
@@ -1402,6 +1475,12 @@ function getValueForAttribute(node, name, expected, isCustomComponentTag) {
 
     var value = node.getAttribute(name);
 
+    if (enableCustomElementPropertySupport) {
+      if (isCustomComponentTag && value === "") {
+        return true;
+      }
+    }
+
     {
       checkAttributeStringCoercion(expected, name);
     }
@@ -1428,10 +1507,57 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
     return;
   }
 
+  if (
+    enableCustomElementPropertySupport &&
+    isCustomComponentTag &&
+    name[0] === "o" &&
+    name[1] === "n"
+  ) {
+    var eventName = name.replace(/Capture$/, "");
+    var useCapture = name !== eventName;
+    eventName = eventName.slice(2);
+    var prevProps = getFiberCurrentPropsFromNode(node);
+    var prevValue = prevProps != null ? prevProps[name] : null;
+
+    if (typeof prevValue === "function") {
+      node.removeEventListener(eventName, prevValue, useCapture);
+    }
+
+    if (typeof value === "function") {
+      if (typeof prevValue !== "function" && prevValue !== null) {
+        // If we previously assigned a non-function type into this node, then
+        // remove it when switching to event listener mode.
+        if (name in node) {
+          node[name] = null;
+        } else if (node.hasAttribute(name)) {
+          node.removeAttribute(name);
+        }
+      } // $FlowFixMe value can't be casted to EventListener.
+
+      node.addEventListener(eventName, value, useCapture);
+      return;
+    }
+  }
+
+  if (
+    enableCustomElementPropertySupport &&
+    isCustomComponentTag &&
+    name in node
+  ) {
+    node[name] = value;
+    return;
+  }
+
   if (shouldRemoveAttribute(name, value, propertyInfo, isCustomComponentTag)) {
     value = null;
   }
 
+  if (enableCustomElementPropertySupport) {
+    if (isCustomComponentTag && value === true) {
+      value = "";
+    }
+  } // If the prop isn't in the special list, treat it as a simple attribute.
+
   if (isCustomComponentTag || propertyInfo === null) {
     if (isAttributeNameSafe(name)) {
       var _attributeName = name;
@@ -1443,7 +1569,10 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
           checkAttributeStringCoercion(value, name);
         }
 
-        node.setAttribute(_attributeName, "" + value);
+        node.setAttribute(
+          _attributeName,
+          enableTrustedTypesIntegration ? value : "" + value
+        );
       }
     }
 
@@ -1483,7 +1612,9 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
     } else {
       // `setAttribute` with objects becomes only `[object]` in IE8/9,
       // ('' + value) makes it output the correct toString()-value.
-      {
+      if (enableTrustedTypesIntegration) {
+        attributeValue = value;
+      } else {
         {
           checkAttributeStringCoercion(value, attributeName);
         }
@@ -1533,6 +1664,7 @@ var REACT_TRACING_MARKER_TYPE = Symbol.for("react.tracing_marker");
 var REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for(
   "react.default_value"
 );
+var REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel");
 var MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
 var FAUX_ITERATOR_SYMBOL = "@@iterator";
 function getIteratorFn(maybeIterable) {
@@ -1671,13 +1803,13 @@ var reentry = false;
 var componentFrameCache;
 
 {
-  var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map;
-  componentFrameCache = new PossiblyWeakMap$1();
+  var PossiblyWeakMap$2 = typeof WeakMap === "function" ? WeakMap : Map;
+  componentFrameCache = new PossiblyWeakMap$2();
 }
 
 function describeNativeComponentFrame(fn, construct) {
   // If something asked for a stack inside a fake render, it should get ignored.
-  if (!fn || reentry) {
+  if (disableNativeComponentFrames || !fn || reentry) {
     return "";
   }
 
@@ -2012,6 +2144,13 @@ function getComponentNameFromType(type) {
     case REACT_CACHE_TYPE: {
       return "Cache";
     }
+
+    // eslint-disable-next-line no-fallthrough
+
+    case REACT_TRACING_MARKER_TYPE:
+      if (enableTransitionTracing) {
+        return "TracingMarker";
+      }
   }
 
   if (typeof type === "object") {
@@ -2158,6 +2297,10 @@ function getComponentNameFromFiber(fiber) {
       }
 
       break;
+
+    case LegacyHiddenComponent: {
+      return "LegacyHidden";
+    }
   }
 
   return null;
@@ -2605,7 +2748,14 @@ function updateWrapper$1(element, props) {
     return;
   }
 
-  {
+  if (disableInputAttributeSyncing) {
+    // When not syncing the value attribute, React only assigns a new value
+    // whenever the defaultValue React prop has changed. When not present,
+    // React does nothing
+    if (props.hasOwnProperty("defaultValue")) {
+      setDefaultValue(node, props.type, getToStringValue(props.defaultValue));
+    }
+  } else {
     // When syncing the value attribute, the value comes from a cascade of
     // properties:
     //  1. The value React property
@@ -2618,7 +2768,16 @@ function updateWrapper$1(element, props) {
     }
   }
 
-  {
+  if (disableInputAttributeSyncing) {
+    // When not syncing the checked attribute, the attribute is directly
+    // controllable from the defaultValue React property. It needs to be
+    // updated as new props come in.
+    if (props.defaultChecked == null) {
+      node.removeAttribute("checked");
+    } else {
+      node.defaultChecked = !!props.defaultChecked;
+    }
+  } else {
     // When syncing the checked attribute, it only changes when it needs
     // to be removed, such as transitioning from a checkbox into a text input
     if (props.checked == null && props.defaultChecked != null) {
@@ -2643,7 +2802,24 @@ function postMountWrapper$3(element, props, isHydrating) {
     // from being lost during SSR hydration.
 
     if (!isHydrating) {
-      {
+      if (disableInputAttributeSyncing) {
+        var value = getToStringValue(props.value); // When not syncing the value attribute, the value property points
+        // directly to the React prop. Only assign it if it exists.
+
+        if (value != null) {
+          // Always assign on buttons so that it is possible to assign an
+          // empty string to clear button text.
+          //
+          // Otherwise, do not re-assign the value property if is empty. This
+          // potentially avoids a DOM write and prevents Firefox (~60.0.1) from
+          // prematurely marking required inputs as invalid. Equality is compared
+          // to the current value in case the browser provided value is not an
+          // empty string.
+          if (isButton || value !== node.value) {
+            node.value = toString(value);
+          }
+        }
+      } else {
         // When syncing the value attribute, the value property should use
         // the wrapperState._initialValue property. This uses:
         //
@@ -2656,7 +2832,15 @@ function postMountWrapper$3(element, props, isHydrating) {
       }
     }
 
-    {
+    if (disableInputAttributeSyncing) {
+      // When not syncing the value attribute, assign the value attribute
+      // directly from the defaultValue React property (when present)
+      var defaultValue = getToStringValue(props.defaultValue);
+
+      if (defaultValue != null) {
+        node.defaultValue = toString(defaultValue);
+      }
+    } else {
       // Otherwise, the value attribute is synchronized to the property,
       // so we assign defaultValue to the same thing as the value property
       // assignment step above.
@@ -2674,7 +2858,22 @@ function postMountWrapper$3(element, props, isHydrating) {
     node.name = "";
   }
 
-  {
+  if (disableInputAttributeSyncing) {
+    // When not syncing the checked attribute, the checked property
+    // never gets assigned. It must be manually set. We don't want
+    // to do this when hydrating so that existing user input isn't
+    // modified
+    if (!isHydrating) {
+      updateChecked(element, props);
+    } // Only assign the checked attribute if it is defined. This saves
+    // a DOM write when controlling the checked attribute isn't needed
+    // (text inputs, submit/reset)
+
+    if (props.hasOwnProperty("defaultChecked")) {
+      node.defaultChecked = !node.defaultChecked;
+      node.defaultChecked = !!props.defaultChecked;
+    }
+  } else {
     // When syncing the checked attribute, both the checked property and
     // attribute are assigned at the same time using defaultChecked. This uses:
     //
@@ -3217,6 +3416,23 @@ var reusableSVGContainer;
 
 var setInnerHTML = createMicrosoftUnsafeLocalFunction(function (node, html) {
   if (node.namespaceURI === SVG_NAMESPACE) {
+    {
+      if (enableTrustedTypesIntegration) {
+        // TODO: reconsider the text of this warning and when it should show
+        // before enabling the feature flag.
+        if (typeof trustedTypes !== "undefined") {
+          error(
+            "Using 'dangerouslySetInnerHTML' in an svg element with " +
+              "Trusted Types enabled in an Internet Explorer will cause " +
+              "the trusted value to be converted to string. Assigning string " +
+              "to 'innerHTML' will throw an error if Trusted Types are enforced. " +
+              "You can try to wrap your svg element inside a div and use 'dangerouslySetInnerHTML' " +
+              "on the enclosing div instead."
+          );
+        }
+      }
+    }
+
     if (!("innerHTML" in node)) {
       // IE does not have innerHTML for SVG nodes, so instead we inject the
       // new markup in a temp node and then move the child nodes across into
@@ -4968,6 +5184,9 @@ function validateProperties(type, props, eventRegistry) {
 var IS_EVENT_HANDLE_NON_MANAGED_NODE = 1;
 var IS_NON_DELEGATED = 1 << 1;
 var IS_CAPTURE_PHASE = 1 << 2;
+var IS_LEGACY_FB_SUPPORT_MODE = 1 << 4;
+var SHOULD_NOT_DEFER_CLICK_FOR_FB_SUPPORT_MODE =
+  IS_LEGACY_FB_SUPPORT_MODE | IS_CAPTURE_PHASE; // We do not want to defer if the event system has already been
 // set to LEGACY_FB_SUPPORT. LEGACY_FB_SUPPORT only gets set when
 // we call willDeferLaterForLegacyFBSupport, thus not bailing out
 // will result in endless cycles like an infinite loop.
@@ -5335,6 +5554,9 @@ function rethrowCaughtError() {
     throw error;
   }
 }
+function hasCaughtError() {
+  return hasError;
+}
 function clearCaughtError() {
   if (hasError) {
     var error = caughtError;
@@ -5433,6 +5655,12 @@ var ShouldCapture =
 var ForceUpdateForLegacySuspense =
   /* */
   131072;
+var DidPropagateContext =
+  /*          */
+  262144;
+var NeedsPropagation =
+  /*             */
+  524288;
 var Forked =
   /*                       */
   1048576; // Static tags describe aspects of a fiber that are not specific to a render,
@@ -5804,17 +6032,23 @@ var scheduleCallback$2 = Scheduler.unstable_scheduleCallback;
 var cancelCallback$1 = Scheduler.unstable_cancelCallback;
 var shouldYield = Scheduler.unstable_shouldYield;
 var requestPaint = Scheduler.unstable_requestPaint;
-var now = Scheduler.unstable_now;
+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 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
@@ -5843,7 +6077,15 @@ function injectInternals(internals) {
   }
 
   try {
-    if (enableSchedulingProfiler);
+    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
+      });
+    }
 
     rendererID = hook.inject(internals); // We have successfully injected, so now it is safe to set up hooks.
 
@@ -5886,10 +6128,37 @@ function onCommitRoot$1(root, eventPriority) {
     try {
       var didError = (root.current.flags & DidCapture) === DidCapture;
 
-      var schedulerPriority;
-      if (enableProfilerTimer);
-      else {
-        injectedHook.onCommitFiberRoot(rendererID, root, undefined, didError);
+      if (enableProfilerTimer) {
+        var schedulerPriority;
+
+        switch (eventPriority) {
+          case DiscreteEventPriority:
+            schedulerPriority = ImmediatePriority;
+            break;
+
+          case ContinuousEventPriority:
+            schedulerPriority = UserBlockingPriority;
+            break;
+
+          case DefaultEventPriority:
+            schedulerPriority = NormalPriority$1;
+            break;
+
+          case IdleEventPriority:
+            schedulerPriority = IdlePriority;
+            break;
+
+          default:
+            schedulerPriority = NormalPriority$1;
+            break;
+        }
+
+        injectedHook.onCommitFiberRoot(
+          rendererID,
+          root,
+          schedulerPriority,
+          didError
+        );
       }
     } catch (err) {
       {
@@ -5935,15 +6204,302 @@ function onCommitUnmount(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) {}
+function injectProfilingHooks(profilingHooks) {
+  injectedProfilingHooks = profilingHooks;
+}
 
 function getLaneLabelMap() {
-  {
+  if (enableSchedulingProfiler) {
+    var map = new Map();
+    var lane = 1;
+
+    for (var index = 0; index < TotalLanes; index++) {
+      var label = getLabelForLane(lane);
+      map.set(lane, label);
+      lane *= 2;
+    }
+
+    return map;
+  } else {
     return null;
   }
 }
 
+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 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 NoMode =
   /*                         */
   0; // TODO: Remove ConcurrentMode by reading from the root tag instead
@@ -5954,6 +6510,9 @@ var ConcurrentMode =
 var ProfileMode =
   /*                    */
   2;
+var DebugTracingMode =
+  /*               */
+  4;
 var StrictLegacyMode =
   /*               */
   8;
@@ -5969,7 +6528,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 = Math.log;
+var log$1 = Math.log;
 var LN2 = Math.LN2;
 
 function clz32Fallback(x) {
@@ -5979,7 +6538,7 @@ function clz32Fallback(x) {
     return 32;
   }
 
-  return (31 - ((log(asUint) / LN2) | 0)) | 0;
+  return (31 - ((log$1(asUint) / LN2) | 0)) | 0;
 }
 
 // If those values are changed that package should be rebuilt and redeployed.
@@ -6097,12 +6656,69 @@ var IdleLane =
 var OffscreenLane =
   /*                   */
   1073741824; // This function is used for the experimental timeline (react-devtools-timeline)
+// It should be kept in sync with the Lanes values above.
+
+function getLabelForLane(lane) {
+  if (enableSchedulingProfiler) {
+    if (lane & SyncHydrationLane) {
+      return "SyncHydrationLane";
+    }
+
+    if (lane & SyncLane) {
+      return "Sync";
+    }
+
+    if (lane & InputContinuousHydrationLane) {
+      return "InputContinuousHydration";
+    }
+
+    if (lane & InputContinuousLane) {
+      return "InputContinuous";
+    }
+
+    if (lane & DefaultHydrationLane) {
+      return "DefaultHydration";
+    }
+
+    if (lane & DefaultLane) {
+      return "Default";
+    }
+
+    if (lane & TransitionHydrationLane) {
+      return "TransitionHydration";
+    }
+
+    if (lane & TransitionLanes) {
+      return "Transition";
+    }
+
+    if (lane & RetryLanes) {
+      return "Retry";
+    }
+
+    if (lane & SelectiveHydrationLane) {
+      return "SelectiveHydration";
+    }
+
+    if (lane & IdleHydrationLane) {
+      return "IdleHydration";
+    }
+
+    if (lane & IdleLane) {
+      return "Idle";
+    }
+
+    if (lane & OffscreenLane) {
+      return "Offscreen";
+    }
+  }
+}
 var NoTimestamp = -1;
 var nextTransitionLane = TransitionLane1;
 var nextRetryLane = RetryLane1;
 
 function getHighestPriorityLanes(lanes) {
-  {
+  if (enableUnifiedSyncLane) {
     var pendingSyncLanes = lanes & SyncUpdateLanes;
 
     if (pendingSyncLanes !== 0) {
@@ -6693,7 +7309,7 @@ function getBumpedLaneForHydration(root, renderLanes) {
   var renderLane = getHighestPriorityLane(renderLanes);
   var lane;
 
-  if ((renderLane & SyncUpdateLanes) !== NoLane) {
+  if (enableUnifiedSyncLane && (renderLane & SyncUpdateLanes) !== NoLane) {
     lane = SyncHydrationLane;
   } else {
     switch (renderLane) {
@@ -6753,10 +7369,105 @@ function getBumpedLaneForHydration(root, renderLanes) {
 
   return lane;
 }
+function addFiberToLanesMap(root, fiber, lanes) {
+  if (!isDevToolsPresent) {
+    return;
+  }
+
+  var pendingUpdatersLaneMap = root.pendingUpdatersLaneMap;
+
+  while (lanes > 0) {
+    var index = laneToIndex(lanes);
+    var lane = 1 << index;
+    var updaters = pendingUpdatersLaneMap[index];
+    updaters.add(fiber);
+    lanes &= ~lane;
+  }
+}
+function movePendingFibersToMemoized(root, lanes) {
+  if (!isDevToolsPresent) {
+    return;
+  }
+
+  var pendingUpdatersLaneMap = root.pendingUpdatersLaneMap;
+  var memoizedUpdaters = root.memoizedUpdaters;
+
+  while (lanes > 0) {
+    var index = laneToIndex(lanes);
+    var lane = 1 << index;
+    var updaters = pendingUpdatersLaneMap[index];
+
+    if (updaters.size > 0) {
+      updaters.forEach(function (fiber) {
+        var alternate = fiber.alternate;
+
+        if (alternate === null || !memoizedUpdaters.has(alternate)) {
+          memoizedUpdaters.add(fiber);
+        }
+      });
+      updaters.clear();
+    }
+
+    lanes &= ~lane;
+  }
+}
+function addTransitionToLanesMap(root, transition, lane) {
+  if (enableTransitionTracing) {
+    var transitionLanesMap = root.transitionLanes;
+    var index = laneToIndex(lane);
+    var transitions = transitionLanesMap[index];
+
+    if (transitions === null) {
+      transitions = new Set();
+    }
+
+    transitions.add(transition);
+    transitionLanesMap[index] = transitions;
+  }
+}
 function getTransitionsForLanes(root, lanes) {
-  {
+  if (!enableTransitionTracing) {
+    return null;
+  }
+
+  var transitionsForLanes = [];
+
+  while (lanes > 0) {
+    var index = laneToIndex(lanes);
+    var lane = 1 << index;
+    var transitions = root.transitionLanes[index];
+
+    if (transitions !== null) {
+      transitions.forEach(function (transition) {
+        transitionsForLanes.push(transition);
+      });
+    }
+
+    lanes &= ~lane;
+  }
+
+  if (transitionsForLanes.length === 0) {
     return null;
   }
+
+  return transitionsForLanes;
+}
+function clearTransitionsForLanes(root, lanes) {
+  if (!enableTransitionTracing) {
+    return;
+  }
+
+  while (lanes > 0) {
+    var index = laneToIndex(lanes);
+    var lane = 1 << index;
+    var transitions = root.transitionLanes[index];
+
+    if (transitions !== null) {
+      root.transitionLanes[index] = null;
+    }
+
+    lanes &= ~lane;
+  }
 }
 
 var DiscreteEventPriority = SyncLane;
@@ -6823,6 +7534,10 @@ function setAttemptSynchronousHydration(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;
@@ -6854,6 +7569,9 @@ var queuedPointers = new Map();
 var queuedPointerCaptures = new Map(); // We could consider replaying selectionchange and touchmoves too.
 
 var queuedExplicitHydrationTargets = [];
+function hasQueuedDiscreteEvents() {
+  return queuedDiscreteEvents.length > 0;
+}
 var discreteReplayableEvents = [
   "mousedown",
   "mouseup",
@@ -6904,6 +7622,53 @@ function createQueuedReplayableEvent(
   };
 }
 
+function queueDiscreteEvent(
+  blockedOn,
+  domEventName,
+  eventSystemFlags,
+  targetContainer,
+  nativeEvent
+) {
+  if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    return;
+  }
+
+  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 (fiber === null) {
+        break;
+      }
+
+      attemptSynchronousHydration$1(fiber);
+
+      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.
+
+        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.
+
 function clearIfContinuousEvent(domEventName, nativeEvent) {
   switch (domEventName) {
     case "focusin":
@@ -7161,7 +7926,7 @@ function attemptReplayContinuousQueuedEvent(queuedEvent) {
     );
 
     if (nextBlockedOn === null) {
-      {
+      if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
         var nativeEvent = queuedEvent.nativeEvent;
         var nativeEventClone = new nativeEvent.constructor(
           nativeEvent.type,
@@ -7170,6 +7935,16 @@ function attemptReplayContinuousQueuedEvent(queuedEvent) {
         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.
@@ -7198,6 +7973,63 @@ function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
 function replayUnblockedEvents() {
   hasScheduledReplayAttempt = false;
 
+  if (!enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+    // First replay discrete events.
+    while (queuedDiscreteEvents.length > 0) {
+      var nextDiscreteEvent = queuedDiscreteEvents[0];
+
+      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$1(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();
+      }
+
+      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;
   }
@@ -7382,16 +8214,116 @@ function dispatchEvent(
     return;
   }
 
-  {
+  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);
+    }
+
+    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;
+    } // We need to clear only if we didn't queue because
+    // queueing is accumulative.
+
+    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.
+
+  dispatchEventForPluginEventSystem(
+    domEventName,
+    eventSystemFlags,
+    nativeEvent,
+    null,
+    targetContainer
+  );
+}
+
 function dispatchEventWithEnableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay(
   domEventName,
   eventSystemFlags,
@@ -7693,6 +8625,9 @@ function addEventBubbleListenerWithPassiveFlag(
   });
   return listener;
 }
+function removeEventListener(target, eventType, listener, capture) {
+  target.removeEventListener(eventType, listener, capture);
+}
 
 /**
  * These variables store information about text content of a target node,
@@ -9065,7 +10000,7 @@ function handleControlledInputBlur(node) {
     return;
   }
 
-  {
+  if (!disableInputAttributeSyncing) {
     // If controlled, assign the value attribute to the current value on blur
     setDefaultValue(node, "number", node.value);
   }
@@ -9104,7 +10039,13 @@ function extractEvents$4(
     }
   } else if (shouldUseClickEvent(targetNode)) {
     getTargetInstFunc = getTargetInstForClickEvent;
-  } else;
+  } else if (
+    enableCustomElementPropertySupport &&
+    targetInst &&
+    isCustomComponent(targetInst.elementType, targetInst.memoizedProps)
+  ) {
+    getTargetInstFunc = getTargetInstForChangeEvent;
+  }
 
   if (getTargetInstFunc) {
     var inst = getTargetInstFunc(domEventName, targetInst);
@@ -10606,33 +11547,93 @@ function addTrappedEventListener(
     }
   }
 
-  targetContainer = targetContainer;
+  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]
+
+    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];
+      }
+
+      return originalListener.apply(this, p);
+    };
+  } // TODO: There are too many combinations here. Consolidate them.
 
   if (isCapturePhaseListener) {
     if (isPassiveListener !== undefined) {
-      addEventCaptureListenerWithPassiveFlag(
+      unsubscribeListener = addEventCaptureListenerWithPassiveFlag(
         targetContainer,
         domEventName,
         listener,
         isPassiveListener
       );
     } else {
-      addEventCaptureListener(targetContainer, domEventName, listener);
+      unsubscribeListener = addEventCaptureListener(
+        targetContainer,
+        domEventName,
+        listener
+      );
     }
   } else {
     if (isPassiveListener !== undefined) {
-      addEventBubbleListenerWithPassiveFlag(
+      unsubscribeListener = addEventBubbleListenerWithPassiveFlag(
         targetContainer,
         domEventName,
         listener,
         isPassiveListener
       );
     } else {
-      addEventBubbleListener(targetContainer, domEventName, listener);
+      unsubscribeListener = addEventBubbleListener(
+        targetContainer,
+        domEventName,
+        listener
+      );
     }
   }
 }
 
+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 ||
@@ -10655,6 +11656,22 @@ function dispatchEventForPluginEventSystem(
     (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 (targetInst !== null) {
       // The below logic attempts to work out if we need to change
@@ -11108,6 +12125,7 @@ function getListenerSetKey(domEventName, capture) {
 }
 
 var didWarnInvalidHydration = false;
+var didWarnScriptTags = false;
 var DANGEROUSLY_SET_INNER_HTML = "dangerouslySetInnerHTML";
 var SUPPRESS_CONTENT_EDITABLE_WARNING = "suppressContentEditableWarning";
 var SUPPRESS_HYDRATION_WARNING$1 = "suppressHydrationWarning";
@@ -11395,6 +12413,19 @@ function createPotentiallyInlineScriptElement(ownerDocument) {
   // set to true and it does not execute
   var div = ownerDocument.createElement("div");
 
+  {
+    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;
+    }
+  }
+
   div.innerHTML = "<script><" + "/script>"; // eslint-disable-line
   // This is guaranteed to yield a script element.
 
@@ -12111,10 +13142,36 @@ function diffHydratedProperties(
             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());
+
+        {
+          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);
+        serverValue = getValueForAttribute(
+          domElement,
+          propKey,
+          nextProp,
+          isCustomComponentTag
+        );
 
         if (nextProp !== serverValue) {
           warnForPropDifference(propKey, serverValue, nextProp);
@@ -12166,10 +13223,18 @@ function diffHydratedProperties(
             extraAttributeNames.delete(propKey);
           }
 
-          serverValue = getValueForAttribute(domElement, propKey, nextProp);
+          serverValue = getValueForAttribute(
+            domElement,
+            propKey,
+            nextProp,
+            isCustomComponentTag
+          );
         }
 
-        var dontWarnCustomElement = enableCustomElementPropertySupport;
+        var dontWarnCustomElement =
+          enableCustomElementPropertySupport &&
+          isCustomComponentTag &&
+          (typeof nextProp === "function" || typeof nextProp === "object");
 
         if (
           !dontWarnCustomElement &&
@@ -14396,6 +15461,10 @@ 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;
 }
@@ -15329,6 +16398,13 @@ function setupIntersectionObserver(targets, callback, options) {
     }
   };
 }
+function requestPostPaintCallback(callback) {
+  localRequestAnimationFrame(function () {
+    localRequestAnimationFrame(function (time) {
+      return callback(time);
+    });
+  });
+} // -------------------
 function isHostHoistableType(type, props, hostContext) {
   var outsideHostContainerContext;
   var namespace;
@@ -15923,6 +16999,223 @@ function throwError(error) {
   throw error;
 }
 
+var nativeConsole = console;
+var nativeConsoleLog = null;
+var pendingGroupArgs = [];
+var printedGroupIndex = -1;
+
+function formatLanes(laneOrLanes) {
+  return "0b" + laneOrLanes.toString(2).padStart(31, "0");
+}
+
+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 groupEnd() {
+  pendingGroupArgs.pop();
+
+  while (printedGroupIndex >= pendingGroupArgs.length) {
+    nativeConsole.groupEnd();
+    printedGroupIndex--;
+  }
+
+  if (pendingGroupArgs.length === 0) {
+    nativeConsole.log = nativeConsoleLog;
+    nativeConsoleLog = 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);
+    }
+
+    printedGroupIndex = pendingGroupArgs.length - 1;
+  }
+
+  if (typeof nativeConsoleLog === "function") {
+    nativeConsoleLog.apply(void 0, arguments);
+  } else {
+    nativeConsole.log.apply(nativeConsole, arguments);
+  }
+}
+
+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();
+    }
+  }
+}
+var PossiblyWeakMap$1 = typeof WeakMap === "function" ? WeakMap : Map; // $FlowFixMe: Flow cannot handle polymorphic WeakMaps
+
+var wakeableIDs = new PossiblyWeakMap$1();
+var wakeableID = 0;
+
+function getWakeableID(wakeable) {
+  if (!wakeableIDs.has(wakeable)) {
+    wakeableIDs.set(wakeable, wakeableID++);
+  }
+
+  return wakeableIDs.get(wakeable);
+}
+
+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 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
+      );
+    }
+  }
+}
+
 // 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.
@@ -16132,6 +17425,11 @@ function markDidThrowWhileHydratingDEV() {
     didSuspendOrErrorDEV = true;
   }
 }
+function didSuspendOrErrorWhileHydratingDEV() {
+  {
+    return didSuspendOrErrorDEV;
+  }
+}
 
 function enterHydrationState(fiber) {
   var parentInstance = fiber.stateNode.containerInfo;
@@ -17199,7 +18497,7 @@ function enqueueUpdate(fiber, update, lane) {
     }
   }
 
-  if (isUnsafeClassRenderPhaseUpdate()) {
+  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;
@@ -17351,6 +18649,16 @@ function getStateFromUpdate(
         var nextState = payload.call(instance, prevState, nextProps);
 
         {
+          if (workInProgress.mode & StrictLegacyMode) {
+            setIsStrictModeForDevtools(true);
+
+            try {
+              payload.call(instance, prevState, nextProps);
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
+
           exitDisallowedContextReadInDEV();
         }
 
@@ -17379,6 +18687,16 @@ function getStateFromUpdate(
         partialState = _payload.call(instance, prevState, nextProps);
 
         {
+          if (workInProgress.mode & StrictLegacyMode) {
+            setIsStrictModeForDevtools(true);
+
+            try {
+              _payload.call(instance, prevState, nextProps);
+            } finally {
+              setIsStrictModeForDevtools(false);
+            }
+          }
+
           exitDisallowedContextReadInDEV();
         }
       } else {
@@ -20273,7 +21591,8 @@ function renderWithHooks(
   //
   // There are plenty of tests to ensure this behavior is correct.
 
-  var shouldDoubleRenderDEV = debugRenderPhaseSideEffectsForStrictMode;
+  var shouldDoubleRenderDEV =
+    (workInProgress.mode & StrictLegacyMode) !== NoMode;
   shouldDoubleInvokeUserFnsInHooksDEV = shouldDoubleRenderDEV;
   var children = Component(props, secondArg);
   shouldDoubleInvokeUserFnsInHooksDEV = false; // Check if there was a render phase update
@@ -20289,6 +21608,22 @@ function renderWithHooks(
     );
   }
 
+  if (shouldDoubleRenderDEV) {
+    // In development, components are invoked twice to help detect side effects.
+    setIsStrictModeForDevtools(true);
+
+    try {
+      children = renderWithHooksAgain(
+        workInProgress,
+        Component,
+        props,
+        secondArg
+      );
+    } finally {
+      setIsStrictModeForDevtools(false);
+    }
+  }
+
   finishRenderingHooks(current, workInProgress);
   return children;
 }
@@ -20346,6 +21681,28 @@ function finishRenderingHooks(current, workInProgress) {
     );
   }
 
+  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();
+        }
+      }
+    }
+  }
+
   {
     if (checkIfUseWrappedInTryCatch()) {
       var componentName =
@@ -20627,7 +21984,8 @@ var createFunctionComponentUpdateQueue;
     return {
       lastEffect: null,
       events: null,
-      stores: null
+      stores: null,
+      memoCache: null
     };
   };
 }
@@ -20676,6 +22034,73 @@ function use(usable) {
   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
+
+  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;
+
+    if (current !== null) {
+      var currentUpdateQueue = current.updateQueue;
+
+      if (currentUpdateQueue !== null) {
+        var currentMemoCache = currentUpdateQueue.memoCache;
+
+        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
+
+  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);
+
+    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
+      );
+    }
+  }
+
+  memoCache.index++;
+  return data;
+}
+
 function basicStateReducer(state, action) {
   // $FlowFixMe: Flow doesn't like mixed types
   return typeof action === "function" ? action(state) : action;
@@ -21456,10 +22881,86 @@ function pushEffect(tag, create, destroy, deps) {
   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");
+  }
+
+  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 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;
+
+              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"
+              );
+            }
+          }
+
+          return current;
+        },
+
+        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;
+        }
+      };
+      Object.seal(ref);
+      hook.memoizedState = ref;
+      return ref;
+    }
+  } else {
     var _ref2 = {
       current: initialValue
     };
@@ -21530,6 +23031,62 @@ function updateEffect(create, deps) {
   updateEffectImpl(Passive$1, Passive, create, deps);
 }
 
+function useEffectEventImpl(payload) {
+  currentlyRenderingFiber$1.flags |= Update;
+  var componentUpdateQueue = currentlyRenderingFiber$1.updateQueue;
+
+  if (componentUpdateQueue === null) {
+    componentUpdateQueue = createFunctionComponentUpdateQueue();
+    currentlyRenderingFiber$1.updateQueue = componentUpdateQueue;
+    componentUpdateQueue.events = [payload];
+  } else {
+    var events = componentUpdateQueue.events;
+
+    if (events === null) {
+      componentUpdateQueue.events = [payload];
+    } else {
+      events.push(payload);
+    }
+  }
+}
+
+function mountEvent(callback) {
+  var hook = mountWorkInProgressHook();
+  var ref = {
+    impl: callback
+  };
+  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 ref.impl.apply(undefined, arguments);
+  };
+}
+
+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."
+      );
+    }
+
+    return ref.impl.apply(undefined, arguments);
+  };
+}
+
 function mountInsertionEffect(create, deps) {
   mountEffectImpl(Update, Insertion, create, deps);
 }
@@ -21776,6 +23333,13 @@ function startTransition(setPending, callback, options) {
   ReactCurrentBatchConfig$2.transition = {};
   var currentTransition = ReactCurrentBatchConfig$2.transition;
 
+  if (enableTransitionTracing) {
+    if (options !== undefined && options.name !== undefined) {
+      ReactCurrentBatchConfig$2.transition.name = options.name;
+      ReactCurrentBatchConfig$2.transition.startTime = now$1();
+    }
+  }
+
   {
     ReactCurrentBatchConfig$2.transition._updatedFibers = new Set();
   }
@@ -21965,6 +23529,8 @@ function dispatchReducerAction(fiber, queue, action) {
       entangleTransitionUpdate(root, queue, lane);
     }
   }
+
+  markUpdateInDevTools(fiber, lane, action);
 }
 
 function dispatchSetState(fiber, queue, action) {
@@ -22047,6 +23613,8 @@ function dispatchSetState(fiber, queue, action) {
       entangleTransitionUpdate(root, queue, lane);
     }
   }
+
+  markUpdateInDevTools(fiber, lane, action);
 }
 
 function isRenderPhaseUpdate(fiber) {
@@ -22095,6 +23663,21 @@ function entangleTransitionUpdate(root, queue, lane) {
   }
 }
 
+function markUpdateInDevTools(fiber, lane, action) {
+  {
+    if (enableDebugTracing) {
+      if (fiber.mode & DebugTracingMode) {
+        var name = getComponentNameFromFiber(fiber) || "Unknown";
+        logStateUpdateScheduled(name, lane, action);
+      }
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markStateUpdateScheduled(fiber, lane);
+  }
+}
+
 var ContextOnlyDispatcher = {
   readContext: readContext,
   useCallback: throwInvalidHookError,
@@ -22123,6 +23706,14 @@ var ContextOnlyDispatcher = {
   ContextOnlyDispatcher.use = throwInvalidHookError;
 }
 
+{
+  ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+}
+
+{
+  ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
+}
+
 var HooksDispatcherOnMountInDEV = null;
 var HooksDispatcherOnMountWithHookTypesInDEV = null;
 var HooksDispatcherOnUpdateInDEV = null;
@@ -22278,6 +23869,20 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     HooksDispatcherOnMountInDEV.use = use;
   }
 
+  {
+    HooksDispatcherOnMountInDEV.useMemoCache = useMemoCache;
+  }
+
+  {
+    HooksDispatcherOnMountInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      mountHookTypesDev();
+      return mountEvent(callback);
+    };
+  }
+
   HooksDispatcherOnMountWithHookTypesInDEV = {
     readContext: function (context) {
       return readContext(context);
@@ -22401,6 +24006,19 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     HooksDispatcherOnMountWithHookTypesInDEV.use = use;
   }
 
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useMemoCache = useMemoCache;
+  }
+
+  {
+    HooksDispatcherOnMountWithHookTypesInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        updateHookTypesDev();
+        return mountEvent(callback);
+      };
+  }
+
   HooksDispatcherOnUpdateInDEV = {
     readContext: function (context) {
       return readContext(context);
@@ -22523,6 +24141,20 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     HooksDispatcherOnUpdateInDEV.use = use;
   }
 
+  {
+    HooksDispatcherOnUpdateInDEV.useMemoCache = useMemoCache;
+  }
+
+  {
+    HooksDispatcherOnUpdateInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      updateHookTypesDev();
+      return updateEvent(callback);
+    };
+  }
+
   HooksDispatcherOnRerenderInDEV = {
     readContext: function (context) {
       return readContext(context);
@@ -22646,6 +24278,20 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     HooksDispatcherOnRerenderInDEV.use = use;
   }
 
+  {
+    HooksDispatcherOnRerenderInDEV.useMemoCache = useMemoCache;
+  }
+
+  {
+    HooksDispatcherOnRerenderInDEV.useEffectEvent = function useEffectEvent(
+      callback
+    ) {
+      currentHookNameInDev = "useEffectEvent";
+      updateHookTypesDev();
+      return updateEvent(callback);
+    };
+  }
+
   InvalidNestedHooksDispatcherOnMountInDEV = {
     readContext: function (context) {
       warnInvalidContextAccess();
@@ -22789,6 +24435,23 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     };
   }
 
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
+  }
+
+  {
+    InvalidNestedHooksDispatcherOnMountInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        mountHookTypesDev();
+        return mountEvent(callback);
+      };
+  }
+
   InvalidNestedHooksDispatcherOnUpdateInDEV = {
     readContext: function (context) {
       warnInvalidContextAccess();
@@ -22932,6 +24595,23 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
     };
   }
 
+  {
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
+  }
+
+  {
+    InvalidNestedHooksDispatcherOnUpdateInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEvent(callback);
+      };
+  }
+
   InvalidNestedHooksDispatcherOnRerenderInDEV = {
     readContext: function (context) {
       warnInvalidContextAccess();
@@ -23074,17 +24754,188 @@ var InvalidNestedHooksDispatcherOnRerenderInDEV = null;
       return use(usable);
     };
   }
+
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useMemoCache = function (size) {
+      warnInvalidHookAccess();
+      return useMemoCache(size);
+    };
+  }
+
+  {
+    InvalidNestedHooksDispatcherOnRerenderInDEV.useEffectEvent =
+      function useEffectEvent(callback) {
+        currentHookNameInDev = "useEffectEvent";
+        warnInvalidHookAccess();
+        updateHookTypesDev();
+        return updateEvent(callback);
+      };
+  }
 }
 
-function recordLayoutEffectDuration(fiber) {
+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 currentUpdateIsNested = false;
+var nestedUpdateScheduled = false;
+
+function isCurrentUpdateNested() {
+  return currentUpdateIsNested;
+}
+
+function markNestedUpdateScheduled() {
   {
-    return;
+    nestedUpdateScheduled = true;
   }
 }
 
-function startLayoutEffectTimer() {
+function resetNestedUpdateFlag() {
   {
-    return;
+    currentUpdateIsNested = false;
+    nestedUpdateScheduled = false;
+  }
+}
+
+function syncNestedUpdateFlag() {
+  {
+    currentUpdateIsNested = nestedUpdateScheduled;
+    nestedUpdateScheduled = false;
+  }
+}
+
+function getCommitTime() {
+  return commitTime;
+}
+
+function recordCommitTime() {
+  commitTime = now();
+}
+
+function startProfilerTimer(fiber) {
+  profilerStartTime = now();
+
+  if (fiber.actualStartTime < 0) {
+    fiber.actualStartTime = now();
+  }
+}
+
+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 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;
+    }
+  }
+}
+
+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 parentFiber = fiber.return;
+
+    while (parentFiber !== null) {
+      switch (parentFiber.tag) {
+        case HostRoot:
+          var root = parentFiber.stateNode;
+
+          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 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;
   }
 }
 
@@ -23192,6 +25043,17 @@ function applyDerivedStateFromProps(
   var partialState = getDerivedStateFromProps(nextProps, prevState);
 
   {
+    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.
 
@@ -23233,6 +25095,19 @@ var classComponentUpdater = {
       scheduleUpdateOnFiber(root, fiber, lane, eventTime);
       entangleTransitions(root, fiber, lane);
     }
+
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logStateUpdateScheduled(name, lane, payload);
+        }
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markStateUpdateScheduled(fiber, lane);
+    }
   },
   enqueueReplaceState: function (inst, payload, callback) {
     var fiber = get(inst);
@@ -23256,6 +25131,19 @@ var classComponentUpdater = {
       scheduleUpdateOnFiber(root, fiber, lane, eventTime);
       entangleTransitions(root, fiber, lane);
     }
+
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logStateUpdateScheduled(name, lane, payload);
+        }
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markStateUpdateScheduled(fiber, lane);
+    }
   },
   // $FlowFixMe[missing-local-annot]
   enqueueForceUpdate: function (inst, callback) {
@@ -23279,6 +25167,19 @@ var classComponentUpdater = {
       scheduleUpdateOnFiber(root, fiber, lane, eventTime);
       entangleTransitions(root, fiber, lane);
     }
+
+    {
+      if (enableDebugTracing) {
+        if (fiber.mode & DebugTracingMode) {
+          var name = getComponentNameFromFiber(fiber) || "Unknown";
+          logForceUpdateScheduled(name, lane);
+        }
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markForceUpdateScheduled(fiber, lane);
+    }
   }
 };
 
@@ -23301,6 +25202,21 @@ function checkShouldComponentUpdate(
     );
 
     {
+      if (workInProgress.mode & StrictLegacyMode) {
+        setIsStrictModeForDevtools(true);
+
+        try {
+          // Invoke the function an extra time to help detect side-effects.
+          shouldUpdate = instance.shouldComponentUpdate(
+            newProps,
+            newState,
+            nextContext
+          );
+        } finally {
+          setIsStrictModeForDevtools(false);
+        }
+      }
+
       if (shouldUpdate === undefined) {
         error(
           "%s.shouldComponentUpdate(): Returned undefined instead of a " +
@@ -23603,6 +25519,18 @@ function constructClassInstance(workInProgress, ctor, props) {
 
   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 state = (workInProgress.memoizedState =
     instance.state !== null && instance.state !== undefined
       ? instance.state
@@ -24048,7 +25976,12 @@ function updateClassInstance(
     oldState === newState &&
     !hasContextChanged() &&
     !checkHasForceUpdateAfterProcessing() &&
-    !enableLazyContextPropagation
+    !(
+      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.
@@ -24097,7 +26030,10 @@ function updateClassInstance(
     // 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;
+    (enableLazyContextPropagation &&
+      current !== null &&
+      current.dependencies !== null &&
+      checkIfContextChanged(current.dependencies));
 
   if (shouldUpdate) {
     // In order to support react-lifecycles-compat polyfilled components,
@@ -24357,6 +26293,23 @@ function createClassErrorUpdate(fiber, errorInfo, lane) {
 }
 
 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;
@@ -24502,6 +26455,13 @@ function throwException(
   // The source fiber did not complete.
   sourceFiber.flags |= Incomplete;
 
+  {
+    if (isDevToolsPresent) {
+      // If we have pending work still, restore the original updaters
+      restorePendingUpdaters(root, rootRenderLanes);
+    }
+  }
+
   if (
     value !== null &&
     typeof value === "object" &&
@@ -24509,7 +26469,7 @@ function throwException(
   ) {
     // This is a wakeable. The component suspended.
     var wakeable = value;
-    resetSuspendedComponent(sourceFiber);
+    resetSuspendedComponent(sourceFiber, rootRenderLanes);
 
     {
       if (getIsHydrating() && sourceFiber.mode & ConcurrentMode) {
@@ -24517,6 +26477,15 @@ function throwException(
       }
     }
 
+    {
+      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 suspenseBoundary = getSuspenseHandler();
 
     if (suspenseBoundary !== null) {
@@ -24742,6 +26711,207 @@ function throwException(
   } while (workInProgress !== null);
 }
 
+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 (transitionStart !== null && onTransitionStart != null) {
+        transitionStart.forEach(function (transition) {
+          return onTransitionStart(transition.name, transition.startTime);
+        });
+      }
+
+      var markerProgress = pendingTransitions.markerProgress;
+      var onMarkerProgress = callbacks.onMarkerProgress;
+
+      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 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
+            );
+          });
+        });
+      }
+
+      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;
+                }
+              }
+            });
+
+            if (filteredAborts.length > 0) {
+              onMarkerIncomplete(
+                transition.name,
+                markerName,
+                transition.startTime,
+                filteredAborts
+              );
+            }
+          });
+        });
+      }
+
+      var transitionProgress = pendingTransitions.transitionProgress;
+      var onTransitionProgress = callbacks.onTransitionProgress;
+
+      if (onTransitionProgress != null && transitionProgress !== null) {
+        transitionProgress.forEach(function (pending, transition) {
+          onTransitionProgress(
+            transition.name,
+            transition.startTime,
+            endTime,
+            Array.from(pending.values())
+          );
+        });
+      }
+
+      var transitionComplete = pendingTransitions.transitionComplete;
+      var onTransitionComplete = callbacks.onTransitionComplete;
+
+      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 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 (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);
+        }
+      });
+    }
+
+    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.
+
+    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
+      );
+    }
+  }
+}
+function popMarkerInstance(workInProgress) {
+  if (enableTransitionTracing) {
+    pop(markerInstanceStack, workInProgress);
+  }
+}
+function getMarkerInstances() {
+  if (enableTransitionTracing) {
+    return markerInstanceStack.current;
+  }
+
+  return null;
+}
+
 var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner; // A special exception that's used to unwind the stack when an update flows
 // into a dehydrated boundary.
 
@@ -24866,6 +27036,10 @@ function updateForwardRef(
   var hasId;
   prepareToReadContext(workInProgress, renderLanes);
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
+
   {
     ReactCurrentOwner$1.current = workInProgress;
     setIsRendering(true);
@@ -24881,6 +27055,10 @@ function updateForwardRef(
     setIsRendering(false);
   }
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
+
   if (current !== null && !didReceiveUpdate) {
     bailoutHooks(current, workInProgress, renderLanes);
     return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
@@ -25136,7 +27314,11 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
   var prevState = current !== null ? current.memoizedState : null;
   markRef$1(current, workInProgress);
 
-  if (nextProps.mode === "hidden" || enableLegacyHidden || nextIsDetached) {
+  if (
+    nextProps.mode === "hidden" ||
+    nextProps.mode === "unstable-defer-without-hiding" ||
+    nextIsDetached
+  ) {
     // Rendering a hidden tree.
     var didSuspend = (workInProgress.flags & DidCapture) !== NoFlags$1;
 
@@ -25179,7 +27361,8 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
       return deferHiddenOffscreenComponent(
         current,
         workInProgress,
-        nextBaseLanes
+        nextBaseLanes,
+        renderLanes
       );
     }
 
@@ -25196,7 +27379,7 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         // 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);
+          pushTransition(workInProgress, null, null);
         }
       }
 
@@ -25217,7 +27400,8 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
       return deferHiddenOffscreenComponent(
         current,
         workInProgress,
-        _nextBaseLanes
+        _nextBaseLanes,
+        renderLanes
       );
     } else {
       // This is the second render. The surrounding visible content has already
@@ -25236,7 +27420,7 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         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);
+        pushTransition(workInProgress, prevCachePool, null);
       } // Push the lanes that were skipped when we bailed out.
 
       if (prevState !== null) {
@@ -25260,7 +27444,19 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         _prevCachePool = prevState.cachePool;
       }
 
-      pushTransition(workInProgress, _prevCachePool); // Push the lanes that were skipped when we bailed out.
+      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
@@ -25275,7 +27471,7 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         // using the same cache. Unless the parent changed, since that means
         // there was a refresh.
         if (current !== null) {
-          pushTransition(workInProgress, 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.
@@ -25306,7 +27502,7 @@ function deferHiddenOffscreenComponent(
     // 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);
+      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.
@@ -25314,8 +27510,23 @@ function deferHiddenOffscreenComponent(
   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 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);
@@ -25376,6 +27587,53 @@ function updateCacheComponent(current, workInProgress, 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
+
+  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."
+        );
+      }
+    }
+  }
+
+  var instance = workInProgress.stateNode;
+
+  if (instance !== null) {
+    pushMarkerInstance(workInProgress, instance);
+  }
+
+  var nextChildren = workInProgress.pendingProps.children;
+  reconcileChildren(current, workInProgress, nextChildren, renderLanes);
+  return workInProgress.child;
+}
+
 function updateFragment(current, workInProgress, renderLanes) {
   var nextChildren = workInProgress.pendingProps;
   reconcileChildren(current, workInProgress, nextChildren, renderLanes);
@@ -25389,6 +27647,18 @@ function updateMode(current, workInProgress, renderLanes) {
 }
 
 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;
+    }
+  }
+
   var nextProps = workInProgress.pendingProps;
   var nextChildren = nextProps.children;
   reconcileChildren(current, workInProgress, nextChildren, renderLanes);
@@ -25438,6 +27708,10 @@ function updateFunctionComponent(
   var hasId;
   prepareToReadContext(workInProgress, renderLanes);
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
+
   {
     ReactCurrentOwner$1.current = workInProgress;
     setIsRendering(true);
@@ -25453,6 +27727,10 @@ function updateFunctionComponent(
     setIsRendering(false);
   }
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
+
   if (current !== null && !didReceiveUpdate) {
     bailoutHooks(current, workInProgress, renderLanes);
     return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
@@ -25481,6 +27759,10 @@ function replayFunctionComponent(
 
   prepareToReadContext(workInProgress, renderLanes);
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
+
   var nextChildren = replaySuspendedComponentWithHooks(
     current,
     workInProgress,
@@ -25490,6 +27772,10 @@ function replayFunctionComponent(
   );
   var hasId = checkDidRenderIdHook();
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  }
+
   if (current !== null && !didReceiveUpdate) {
     bailoutHooks(current, workInProgress, renderLanes);
     return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
@@ -25661,13 +27947,35 @@ function finishClassComponent(
     // 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);
+        }
+      }
+
       setIsRendering(false);
     }
+
+    if (enableSchedulingProfiler) {
+      markComponentRenderStopped();
+    }
   } // React DevTools reads this flag.
 
   workInProgress.flags |= PerformedWork;
@@ -25713,6 +28021,11 @@ function updateHostRoot(current, workInProgress, renderLanes) {
   processUpdateQueue(workInProgress, nextProps, null, renderLanes);
   var nextState = workInProgress.memoizedState;
   var root = workInProgress.stateNode;
+  pushRootTransition(workInProgress);
+
+  if (enableTransitionTracing) {
+    pushRootMarkerInstance(workInProgress);
+  }
 
   {
     var nextCache = nextState.cache;
@@ -26105,6 +28418,10 @@ function mountIndeterminateComponent(
   var value;
   var hasId;
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
+
   {
     if (
       Component.prototype &&
@@ -26142,6 +28459,10 @@ function mountIndeterminateComponent(
     setIsRendering(false);
   }
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
+
   workInProgress.flags |= PerformedWork;
 
   {
@@ -26441,6 +28762,27 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
         mountSuspenseOffscreenState(renderLanes);
       workInProgress.memoizedState = SUSPENDED_MARKER;
 
+      if (enableTransitionTracing) {
+        var currentTransitions = getPendingTransitions();
+
+        if (currentTransitions !== null) {
+          var parentMarkerInstances = getMarkerInstances();
+          var offscreenQueue = primaryChildFragment.updateQueue;
+
+          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
@@ -26513,6 +28855,41 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
           ? mountSuspenseOffscreenState(renderLanes)
           : updateSuspenseOffscreenState(prevOffscreenState, renderLanes);
 
+      if (enableTransitionTracing) {
+        var _currentTransitions = getPendingTransitions();
+
+        if (_currentTransitions !== null) {
+          var _parentMarkerInstances = getMarkerInstances();
+
+          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
@@ -26580,6 +28957,17 @@ function mountSuspenseFallbackChildren(
     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;
+    }
+
     fallbackChildFragment = createFiberFromFragment(
       fallbackChildren,
       mode,
@@ -26688,6 +29076,19 @@ function updateSuspenseFallbackChildren(
     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.
 
@@ -26904,6 +29305,17 @@ function updateDehydratedSuspenseComponent(
         capturedValue
       );
     }
+
+    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);
@@ -27510,7 +29922,8 @@ function updateContextProvider(current, workInProgress, renderLanes) {
 
   pushProvider(workInProgress, context, newValue);
 
-  {
+  if (enableLazyContextPropagation);
+  else {
     if (oldProps !== null) {
       var oldValue = oldProps.value;
 
@@ -27584,6 +29997,10 @@ function updateContextConsumer(current, workInProgress, renderLanes) {
   prepareToReadContext(workInProgress, renderLanes);
   var newValue = readContext(context);
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStarted(workInProgress);
+  }
+
   var newChildren;
 
   {
@@ -27593,6 +30010,10 @@ function updateContextConsumer(current, workInProgress, renderLanes) {
     setIsRendering(false);
   }
 
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+  } // React DevTools reads this flag.
+
   workInProgress.flags |= PerformedWork;
   reconcileChildren(current, workInProgress, newChildren, renderLanes);
   return workInProgress.child;
@@ -27608,6 +30029,9 @@ function updateScopeComponent(current, workInProgress, renderLanes) {
 function markWorkInProgressReceivedUpdate() {
   didReceiveUpdate = true;
 }
+function checkIfWorkInProgressReceivedUpdate() {
+  return didReceiveUpdate;
+}
 
 function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
   if ((workInProgress.mode & ConcurrentMode) === NoMode) {
@@ -27630,13 +30054,26 @@ function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
     workInProgress.dependencies = current.dependencies;
   }
 
+  {
+    // 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);
+
+      if (!includesSomeLane(renderLanes, workInProgress.childLanes)) {
+        return null;
+      }
+    } else {
       return null;
     }
   } // This fiber doesn't have work, but its subtree does. Clone the child
@@ -27711,6 +30148,15 @@ function checkScheduledUpdateOrContext(current, renderLanes) {
   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;
+    }
+  }
 
   return false;
 }
@@ -27726,6 +30172,11 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
   switch (workInProgress.tag) {
     case HostRoot:
       pushHostRootContext(workInProgress);
+      pushRootTransition(workInProgress);
+
+      if (enableTransitionTracing) {
+        pushRootMarkerInstance(workInProgress);
+      }
 
       {
         var cache = current.memoizedState.cache;
@@ -27756,6 +30207,26 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
     }
 
     case Profiler:
+      {
+        // Profiler should only call onRender when one of its descendants actually rendered.
+        var hasChildWork = includesSomeLane(
+          renderLanes,
+          workInProgress.childLanes
+        );
+
+        if (hasChildWork) {
+          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;
+        }
+      }
+
       break;
 
     case SuspenseComponent: {
@@ -27823,6 +30294,25 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
         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 (didSuspendBefore) {
         if (_hasChildWork) {
           // If something was in fallback state last time, and we have all the
@@ -27888,6 +30378,16 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
 
       break;
     }
+
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        var instance = workInProgress.stateNode;
+
+        if (instance !== null) {
+          pushMarkerInstance(workInProgress, instance);
+        }
+      }
+    }
   }
 
   return bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes);
@@ -28171,7 +30671,13 @@ function beginWork$1(current, workInProgress, renderLanes) {
     }
 
     case LegacyHiddenComponent: {
-      break;
+      {
+        return updateLegacyHiddenComponent(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      }
     }
 
     case CacheComponent: {
@@ -28179,6 +30685,18 @@ function beginWork$1(current, workInProgress, renderLanes) {
         return updateCacheComponent(current, workInProgress, renderLanes);
       }
     }
+
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        return updateTracingMarkerComponent(
+          current,
+          workInProgress,
+          renderLanes
+        );
+      }
+
+      break;
+    }
   }
 
   throw new Error(
@@ -28307,12 +30825,28 @@ function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
   }
 }
 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) {
@@ -28449,6 +30983,285 @@ function propagateContextChange_eager(workInProgress, context, renderLanes) {
     fiber = nextFiber;
   }
 }
+
+function propagateContextChanges(
+  workInProgress,
+  contexts,
+  renderLanes,
+  forcePropagateEntireTree
+) {
+  // Only used by lazy 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;
+  }
+
+  while (fiber !== null) {
+    var nextFiber = void 0; // Visit this fiber.
+
+    var list = fiber.dependencies;
+
+    if (list !== null) {
+      nextFiber = fiber.child;
+      var dep = list.firstContext;
+
+      findChangedDep: while (dep !== null) {
+        // Assigning these to constants to help Flow
+        var dependency = dep;
+        var consumer = fiber;
+
+        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 (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 (alternate !== null) {
+              alternate.lanes = mergeLanes(alternate.lanes, renderLanes);
+            }
+
+            scheduleContextWorkOnParentPath(
+              consumer.return,
+              renderLanes,
+              workInProgress
+            );
+
+            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.
+
+            break findChangedDep;
+          }
+        }
+
+        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;
+
+      while (nextFiber !== null) {
+        if (nextFiber === workInProgress) {
+          // We're back to the root of this subtree. Exit.
+          nextFiber = null;
+          break;
+        }
+
+        var sibling = nextFiber.sibling;
+
+        if (sibling !== null) {
+          // Set the return pointer of the sibling to the work-in-progress fiber.
+          sibling.return = nextFiber.return;
+          nextFiber = sibling;
+          break;
+        } // No more siblings. Traverse up.
+
+        nextFiber = nextFiber.return;
+      }
+    }
+
+    fiber = nextFiber;
+  }
+}
+
+function 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.
+
+function propagateParentContextChangesToDeferredTree(
+  current,
+  workInProgress,
+  renderLanes
+) {
+  var forcePropagateEntireTree = true;
+  propagateParentContextChanges(
+    current,
+    workInProgress,
+    renderLanes,
+    forcePropagateEntireTree
+  );
+}
+
+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.
+
+  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;
+      }
+    }
+
+    if (parent.tag === ContextProvider) {
+      var currentParent = parent.alternate;
+
+      if (currentParent === null) {
+        throw new Error("Should have a current fiber. This is a bug in React.");
+      }
+
+      var oldProps = currentParent.memoizedProps;
+
+      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;
+  }
+
+  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;
+
+  while (dependency !== null) {
+    var context = dependency.context;
+    var newValue = context._currentValue;
+    var oldValue = dependency.memoizedValue;
+
+    if (!objectIs(newValue, oldValue)) {
+      return true;
+    }
+
+    dependency = dependency.next;
+  }
+
+  return false;
+}
 function prepareToReadContext(workInProgress, renderLanes) {
   currentlyRenderingFiber = workInProgress;
   lastContextDependency = null;
@@ -28456,7 +31269,10 @@ function prepareToReadContext(workInProgress, renderLanes) {
   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) {
@@ -28520,6 +31336,10 @@ function readContextForConsumer(consumer, context) {
         lanes: NoLanes,
         firstContext: contextItem
       };
+
+      if (enableLazyContextPropagation) {
+        consumer.flags |= NeedsPropagation;
+      }
     } else {
       // Append a new context item.
       lastContextDependency = lastContextDependency.next = contextItem;
@@ -28628,6 +31448,12 @@ function requestCurrentTransition() {
 // 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,
@@ -28673,6 +31499,17 @@ function requestCacheFromPool(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,
@@ -28685,14 +31522,39 @@ function pushTransition(
       push(resumedCache, prevCachePool.pool, offscreenWorkInProgress);
     }
   }
+
+  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);
+    }
+
     {
       pop(resumedCache, workInProgress);
     }
   }
 }
+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
@@ -29096,7 +31958,37 @@ function bubbleProperties(completedWork) {
 
   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) {
@@ -29117,7 +32009,30 @@ function bubbleProperties(completedWork) {
     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) {
@@ -29178,6 +32093,23 @@ function completeDehydratedSuspenseBoundary(
       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
@@ -29196,6 +32128,23 @@ function completeDehydratedSuspenseBoundary(
       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 {
@@ -29239,6 +32188,16 @@ function completeWork(current, workInProgress, renderLanes) {
     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;
 
@@ -29255,6 +32214,12 @@ function completeWork(current, workInProgress, renderLanes) {
 
         popCacheProvider(workInProgress);
       }
+
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(workInProgress);
+      }
+
+      popRootTransition(workInProgress);
       popHostContainer(workInProgress);
       resetWorkInProgressVersions();
 
@@ -29298,6 +32263,15 @@ function completeWork(current, workInProgress, renderLanes) {
       }
       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;
     }
 
@@ -29540,6 +32514,10 @@ function completeWork(current, workInProgress, renderLanes) {
         // 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;
       }
 
@@ -29576,6 +32554,10 @@ function completeWork(current, workInProgress, renderLanes) {
       // a passive effect, which is when we process the transitions
 
       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
@@ -29612,6 +32594,21 @@ function completeWork(current, workInProgress, renderLanes) {
 
       bubbleProperties(workInProgress);
 
+      {
+        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 (primaryChildFragment !== null) {
+              // $FlowFixMe Flow doesn't support type casting in combination with the -= operator
+              workInProgress.treeBaseDuration -=
+                primaryChildFragment.treeBaseDuration;
+            }
+          }
+        }
+      }
+
       return null;
     }
 
@@ -29718,7 +32715,7 @@ function completeWork(current, workInProgress, renderLanes) {
             }
           }
 
-          if (renderState.tail !== null && now() > getRenderTargetTime()) {
+          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.
@@ -29771,7 +32768,7 @@ function completeWork(current, workInProgress, renderLanes) {
             // 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() * 2 - renderState.renderingStartTime >
+            now$1() * 2 - renderState.renderingStartTime >
               getRenderTargetTime() &&
             renderLanes !== OffscreenLane
           ) {
@@ -29820,7 +32817,7 @@ function completeWork(current, workInProgress, renderLanes) {
         var next = renderState.tail;
         renderState.rendering = next;
         renderState.tail = next.sibling;
-        renderState.renderingStartTime = now();
+        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.
@@ -29880,7 +32877,8 @@ function completeWork(current, workInProgress, renderLanes) {
       var _nextState = workInProgress.memoizedState;
       var nextIsHidden = _nextState !== null; // Schedule a Visibility effect if the visibility has changed
 
-      {
+      if (workInProgress.tag === LegacyHiddenComponent);
+      else {
         if (current !== null) {
           var _prevState = current.memoizedState;
           var prevIsHidden = _prevState !== null;
@@ -29910,7 +32908,10 @@ function completeWork(current, workInProgress, renderLanes) {
           // If so, we need to hide those nodes in the commit phase, so
           // schedule a visibility effect.
 
-          if (workInProgress.subtreeFlags & (Placement | Update)) {
+          if (
+            workInProgress.tag !== LegacyHiddenComponent &&
+            workInProgress.subtreeFlags & (Placement | Update)
+          ) {
             workInProgress.flags |= Visibility;
           }
         }
@@ -29975,6 +32976,16 @@ function completeWork(current, workInProgress, renderLanes) {
     }
 
     case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        var _instance3 = workInProgress.stateNode;
+
+        if (_instance3 !== null) {
+          popMarkerInstance(workInProgress);
+        }
+
+        bubbleProperties(workInProgress);
+      }
+
       return null;
     }
   }
@@ -30001,6 +33012,10 @@ function unwindWork(current, workInProgress, renderLanes) {
       if (flags & ShouldCapture) {
         workInProgress.flags = (flags & ~ShouldCapture) | DidCapture;
 
+        if ((workInProgress.mode & ProfileMode) !== NoMode) {
+          transferActualDuration(workInProgress);
+        }
+
         return workInProgress;
       }
 
@@ -30011,6 +33026,12 @@ function unwindWork(current, workInProgress, renderLanes) {
       {
         popCacheProvider(workInProgress);
       }
+
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(workInProgress);
+      }
+
+      popRootTransition(workInProgress);
       popHostContainer(workInProgress);
       resetWorkInProgressVersions();
       var _flags = workInProgress.flags;
@@ -30056,6 +33077,10 @@ function unwindWork(current, workInProgress, renderLanes) {
       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;
       }
 
@@ -30088,6 +33113,10 @@ function unwindWork(current, workInProgress, renderLanes) {
       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;
       }
 
@@ -30102,6 +33131,12 @@ function unwindWork(current, workInProgress, renderLanes) {
       return null;
 
     case TracingMarkerComponent:
+      if (enableTransitionTracing) {
+        if (workInProgress.stateNode !== null) {
+          popMarkerInstance(workInProgress);
+        }
+      }
+
       return null;
 
     default:
@@ -30125,6 +33160,12 @@ function unwindInterruptedWork(current, interruptedWork, renderLanes) {
       {
         popCacheProvider(interruptedWork);
       }
+
+      if (enableTransitionTracing) {
+        popRootMarkerInstance(interruptedWork);
+      }
+
+      popRootTransition(interruptedWork);
       popHostContainer(interruptedWork);
       resetWorkInProgressVersions();
       break;
@@ -30166,6 +33207,17 @@ function unwindInterruptedWork(current, interruptedWork, renderLanes) {
         popCacheProvider(interruptedWork);
       }
 
+      break;
+
+    case TracingMarkerComponent:
+      if (enableTransitionTracing) {
+        var instance = interruptedWork.stateNode;
+
+        if (instance !== null) {
+          popMarkerInstance(interruptedWork);
+        }
+      }
+
       break;
   }
 }
@@ -30182,8 +33234,14 @@ 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 enableProfilerTimer;
+  return (
+    (current.mode & ProfileMode) !== NoMode &&
+    (getExecutionContext() & CommitContext) !== NoContext
+  );
 }
 
 function reportUncaughtErrorInDEV(error) {
@@ -30204,7 +33262,14 @@ var callComponentWillUnmountWithTimer = function (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.
@@ -30236,8 +33301,14 @@ function safelyDetachRef(current, nearestMountedAncestor) {
   if (ref !== null) {
     if (typeof refCleanup === "function") {
       try {
-        if (shouldProfile(current));
-        else {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            refCleanup();
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
           refCleanup();
         }
       } catch (error) {
@@ -30255,8 +33326,14 @@ function safelyDetachRef(current, nearestMountedAncestor) {
       var retVal;
 
       try {
-        if (shouldProfile(current));
-        else {
+        if (shouldProfile(current)) {
+          try {
+            startLayoutEffectTimer();
+            retVal = ref(null);
+          } finally {
+            recordLayoutEffectDuration(current);
+          }
+        } else {
           retVal = ref(null);
         }
       } catch (error) {
@@ -30380,6 +33457,12 @@ function commitBeforeMutationEffectsOnFiber(finishedWork) {
 
   switch (finishedWork.tag) {
     case FunctionComponent: {
+      {
+        if ((flags & Update) !== NoFlags$1) {
+          commitUseEffectEventMount(finishedWork);
+        }
+      }
+
       break;
     }
 
@@ -30521,6 +33604,14 @@ function commitHookEffectListUnmount(
         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);
@@ -30534,6 +33625,14 @@ function commitHookEffectListUnmount(
               setIsRunningInsertionEffect(false);
             }
           }
+
+          if (enableSchedulingProfiler) {
+            if ((flags & Passive) !== NoFlags) {
+              markComponentPassiveEffectUnmountStopped();
+            } else if ((flags & Layout) !== NoFlags) {
+              markComponentLayoutEffectUnmountStopped();
+            }
+          }
         }
       }
 
@@ -30552,6 +33651,14 @@ function commitHookEffectListMount(flags, finishedWork) {
 
     do {
       if ((effect.tag & flags) === flags) {
+        if (enableSchedulingProfiler) {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStarted(finishedWork);
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStarted(finishedWork);
+          }
+        } // Mount
+
         var create = effect.create;
 
         {
@@ -30568,6 +33675,14 @@ function commitHookEffectListMount(flags, finishedWork) {
           }
         }
 
+        if (enableSchedulingProfiler) {
+          if ((flags & Passive) !== NoFlags) {
+            markComponentPassiveEffectMountStopped();
+          } else if ((flags & Layout) !== NoFlags) {
+            markComponentLayoutEffectMountStopped();
+          }
+        }
+
         {
           var destroy = effect.destroy;
 
@@ -30624,12 +33739,87 @@ function commitHookEffectListMount(flags, finishedWork) {
   }
 }
 
+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;
+    }
+  }
+}
+
+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";
+
+          {
+            if (isCurrentUpdateNested()) {
+              phase = "nested-update";
+            }
+          }
+
+          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 parentFiber = finishedWork.return;
+
+          outer: while (parentFiber !== null) {
+            switch (parentFiber.tag) {
+              case HostRoot:
+                var root = parentFiber.stateNode;
+                root.passiveEffectDuration += passiveEffectDuration;
+                break outer;
+
+              case Profiler:
+                var parentStateNode = parentFiber.stateNode;
+                parentStateNode.passiveEffectDuration += passiveEffectDuration;
+                break outer;
+            }
+
+            parentFiber = parentFiber.return;
+          }
+
+          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);
+    }
+
+    recordLayoutEffectDuration(finishedWork);
+  } else {
     try {
       commitHookEffectListMount(hookFlags, finishedWork);
     } catch (error) {
@@ -30674,7 +33864,16 @@ function commitClassLayoutLifecycles(finishedWork, current) {
       }
     }
 
-    {
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidMount();
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+
+      recordLayoutEffectDuration(finishedWork);
+    } else {
       try {
         instance.componentDidMount();
       } catch (error) {
@@ -30719,7 +33918,20 @@ function commitClassLayoutLifecycles(finishedWork, current) {
       }
     }
 
-    {
+    if (shouldProfile(finishedWork)) {
+      try {
+        startLayoutEffectTimer();
+        instance.componentDidUpdate(
+          prevProps,
+          prevState,
+          instance.__reactInternalSnapshotBeforeUpdate
+        );
+      } catch (error) {
+        captureCommitPhaseError(finishedWork, finishedWork.return, error);
+      }
+
+      recordLayoutEffectDuration(finishedWork);
+    } else {
       try {
         instance.componentDidUpdate(
           prevProps,
@@ -30792,6 +34004,72 @@ function commitHostComponentMount(finishedWork) {
   }
 }
 
+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
+        );
+      }
+
+      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;
+
+        outer: while (parentFiber !== null) {
+          switch (parentFiber.tag) {
+            case HostRoot:
+              var root = parentFiber.stateNode;
+              root.effectDuration += effectDuration;
+              break outer;
+
+            case Profiler:
+              var parentStateNode = parentFiber.stateNode;
+              parentStateNode.effectDuration += effectDuration;
+              break outer;
+          }
+
+          parentFiber = parentFiber.return;
+        }
+      }
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+  }
+}
+
 function commitLayoutEffectOnFiber(
   finishedRoot,
   current,
@@ -30901,6 +34179,11 @@ function commitLayoutEffectOnFiber(
 
     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);
+      }
 
       break;
     }
@@ -30976,6 +34259,271 @@ function commitLayoutEffectOnFiber(
   }
 }
 
+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 = [];
+        }
+
+        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
+            );
+          }
+        }
+      }
+    });
+  }
+}
+
+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
+
+            if (
+              deletedOffscreenInstance !== null &&
+              !isInDeletedTree &&
+              pendingBoundaries !== null &&
+              pendingBoundaries.has(deletedOffscreenInstance)
+            ) {
+              pendingBoundaries.delete(deletedOffscreenInstance);
+              addMarkerProgressCallbackToPendingTransition(
+                abortedFiber.memoizedProps.name,
+                deletedTransitions,
+                pendingBoundaries
+              );
+            }
+          }
+        }
+      });
+    }
+  }
+}
+
+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;
+
+    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;
+    }
+  }
+}
+
+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 (previousFiber !== null && previousFiber.memoizedState !== null) {
+      prevState = previousFiber.memoizedState;
+    }
+
+    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.
+
+    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;
+
+          if (
+            pendingBoundaries !== null &&
+            pendingBoundaries.has(offscreenInstance)
+          ) {
+            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
+                    );
+                  }
+
+                  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;
@@ -31081,7 +34629,14 @@ function commitAttachRef(finishedWork) {
     }
 
     if (typeof ref === "function") {
-      {
+      if (shouldProfile(finishedWork)) {
+        try {
+          startLayoutEffectTimer();
+          finishedWork.refCleanup = ref(instanceToUse);
+        } finally {
+          recordLayoutEffectDuration(finishedWork);
+        }
+      } else {
         finishedWork.refCleanup = ref(instanceToUse);
       }
     } else {
@@ -31623,13 +35178,29 @@ function commitDeletionEffectsOnFiber(
                     destroy
                   );
                 } else if ((tag & Layout) !== NoFlags) {
-                  {
+                  if (enableSchedulingProfiler) {
+                    markComponentLayoutEffectUnmountStarted(deletedFiber);
+                  }
+
+                  if (shouldProfile(deletedFiber)) {
+                    startLayoutEffectTimer();
+                    safelyCallDestroy(
+                      deletedFiber,
+                      nearestMountedAncestor,
+                      destroy
+                    );
+                    recordLayoutEffectDuration(deletedFiber);
+                  } else {
                     safelyCallDestroy(
                       deletedFiber,
                       nearestMountedAncestor,
                       destroy
                     );
                   }
+
+                  if (enableSchedulingProfiler) {
+                    markComponentLayoutEffectUnmountStopped();
+                  }
                 }
               }
 
@@ -31876,6 +35447,19 @@ function attachSuspenseRetryListeners(finishedWork, wakeables) {
     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."
+            );
+          }
+        }
+      }
+
       wakeable.then(retry, retry);
     }
   });
@@ -31896,9 +35480,13 @@ function isSuspenseBoundaryBeingHidden(current, finishedWork) {
   return false;
 }
 function commitMutationEffects(root, finishedWork, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
   setCurrentFiber(finishedWork);
   commitMutationEffectsOnFiber(finishedWork, root);
   setCurrentFiber(finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
 }
 
 function recursivelyTraverseMutationEffects(root, parentFiber, lanes) {
@@ -31965,7 +35553,20 @@ function commitMutationEffectsOnFiber(finishedWork, root, lanes) {
         // 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);
+          }
+
+          recordLayoutEffectDuration(finishedWork);
+        } else {
           try {
             commitHookEffectListUnmount(
               Layout | HasEffect,
@@ -32464,8 +36065,12 @@ function commitReconciliationEffects(finishedWork) {
 }
 
 function commitLayoutEffects(finishedWork, root, committedLanes) {
+  inProgressLanes = committedLanes;
+  inProgressRoot = root;
   var current = finishedWork.alternate;
   commitLayoutEffectOnFiber(root, current, finishedWork);
+  inProgressLanes = null;
+  inProgressRoot = null;
 }
 
 function recursivelyTraverseLayoutEffects(root, parentFiber, lanes) {
@@ -32492,7 +36097,18 @@ function disappearLayoutEffects(finishedWork) {
     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);
       }
 
@@ -32646,6 +36262,10 @@ function reappearLayoutEffects(
         includeWorkInProgressEffects
       ); // TODO: Figure out how Profiler updates should work with Offscreen
 
+      if (includeWorkInProgressEffects && flags & Update) {
+        commitProfilerUpdate(finishedWork, current);
+      }
+
       break;
     }
 
@@ -32722,7 +36342,17 @@ function recursivelyTraverseReappearLayoutEffects(
 }
 
 function commitHookPassiveMountEffects(finishedWork, hookFlags) {
-  {
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
+
+    try {
+      commitHookEffectListMount(hookFlags, finishedWork);
+    } catch (error) {
+      captureCommitPhaseError(finishedWork, finishedWork.return, error);
+    }
+
+    recordPassiveEffectDuration(finishedWork);
+  } else {
     try {
       commitHookEffectListMount(hookFlags, finishedWork);
     } catch (error) {
@@ -32765,6 +36395,71 @@ function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
       }
     }
   }
+
+  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();
+            }
+
+            instance._transitions.add(transition);
+          });
+        }
+
+        var markerInstances = queue.markerInstances;
+
+        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 (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 (instance._pendingMarkers === null) {
+                    instance._pendingMarkers = new Set();
+                  }
+
+                  instance._pendingMarkers.add(markerInstance);
+                }
+              });
+            }
+          });
+        }
+      }
+
+      finishedWork.updateQueue = null;
+    }
+
+    commitTransitionProgress(finishedWork); // TODO: Refactor this into an if/else branch
+
+    if (!isHidden) {
+      instance._transitions = null;
+      instance._pendingMarkers = null;
+    }
+  }
 }
 
 function commitCachePassiveMountEffect(current, finishedWork) {
@@ -32791,6 +36486,25 @@ function commitCachePassiveMountEffect(current, finishedWork) {
   }
 }
 
+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,
@@ -32893,12 +36607,54 @@ function commitPassiveMountOnFiber(
             }
           }
         }
+
+        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 (pendingBoundaries === null || pendingBoundaries.size === 0) {
+              if (markerInstance.aborts === null) {
+                addTransitionCompleteCallbackToPendingTransition(transition);
+              }
+
+              incompleteTransitions.delete(transition);
+            }
+          });
+          clearTransitionsForLanes(finishedRoot, committedLanes);
+        }
       }
 
       break;
     }
 
     case LegacyHiddenComponent: {
+      {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
+
+        if (flags & Passive$1) {
+          var current = finishedWork.alternate;
+          var instance = finishedWork.stateNode;
+          commitOffscreenPassiveMountEffects(current, finishedWork, instance);
+        }
+      }
+
       break;
     }
 
@@ -32970,7 +36726,7 @@ function commitPassiveMountOnFiber(
 
       if (flags & Passive$1) {
         var _current = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(_current, finishedWork);
+        commitOffscreenPassiveMountEffects(_current, finishedWork, _instance3);
       }
 
       break;
@@ -32993,7 +36749,22 @@ function commitPassiveMountOnFiber(
       break;
     }
 
-    case TracingMarkerComponent:
+    case TracingMarkerComponent: {
+      if (enableTransitionTracing) {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
+
+        if (flags & Passive$1) {
+          commitTracingMarkerPassiveMountEffect(finishedWork);
+        }
+
+        break;
+      } // Intentional fallthrough to next branch
+    }
     // eslint-disable-next-line-no-fallthrough
 
     default: {
@@ -33073,6 +36844,23 @@ function reconnectPassiveEffects(
     // }
 
     case LegacyHiddenComponent: {
+      {
+        recursivelyTraverseReconnectPassiveEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions,
+          includeWorkInProgressEffects
+        );
+
+        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);
+        }
+      }
+
       break;
     }
 
@@ -33136,7 +36924,7 @@ function reconnectPassiveEffects(
       if (includeWorkInProgressEffects && flags & Passive$1) {
         // TODO: Pass `current` as argument to this function
         var _current3 = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(_current3, finishedWork);
+        commitOffscreenPassiveMountEffects(_current3, finishedWork, _instance4);
       }
 
       break;
@@ -33160,7 +36948,23 @@ function reconnectPassiveEffects(
       break;
     }
 
-    case TracingMarkerComponent:
+    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
 
     default: {
@@ -33218,7 +37022,8 @@ function commitAtomicPassiveEffects(
       if (flags & Passive$1) {
         // TODO: Pass `current` as argument to this function
         var current = finishedWork.alternate;
-        commitOffscreenPassiveMountEffects(current, finishedWork);
+        var instance = finishedWork.stateNode;
+        commitOffscreenPassiveMountEffects(current, finishedWork, instance);
       }
 
       break;
@@ -33285,7 +37090,15 @@ function commitHookPassiveUnmountEffects(
   nearestMountedAncestor,
   hookFlags
 ) {
-  {
+  if (shouldProfile(finishedWork)) {
+    startPassiveEffectTimer();
+    commitHookEffectListUnmount(
+      hookFlags,
+      finishedWork,
+      nearestMountedAncestor
+    );
+    recordPassiveEffectDuration(finishedWork);
+  } else {
     commitHookEffectListUnmount(
       hookFlags,
       finishedWork,
@@ -33545,6 +37358,43 @@ function commitPassiveUnmountInsideDeletedTreeOnFiber(
     }
 
     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
+              );
+            }
+          }
+        }
+      }
+
       break;
     }
 
@@ -33556,6 +37406,40 @@ function commitPassiveUnmountInsideDeletedTreeOnFiber(
 
       break;
     }
+
+    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;
+    }
   }
 }
 
@@ -34219,6 +38103,24 @@ function isConcurrentActEnvironment() {
   }
 }
 
+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);
+      }
+
+      postPaintCallbackScheduled = false;
+      callbacks = [];
+    });
+  }
+}
+
 var ceil = Math.ceil;
 var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
 var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
@@ -34306,9 +38208,157 @@ var workInProgressRootRenderTargetTime = Infinity; // How long a render is suppo
 
 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
+      };
+    }
+
+    if (currentPendingTransitionCallbacks.transitionStart === null) {
+      currentPendingTransitionCallbacks.transitionStart = [];
+    }
+
+    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
+      };
+    }
+
+    if (currentPendingTransitionCallbacks.markerProgress === null) {
+      currentPendingTransitionCallbacks.markerProgress = new Map();
+    }
+
+    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 (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 (currentPendingTransitionCallbacks.markerComplete === null) {
+      currentPendingTransitionCallbacks.markerComplete = new Map();
+    }
+
+    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 (currentPendingTransitionCallbacks.transitionProgress === null) {
+      currentPendingTransitionCallbacks.transitionProgress = new Map();
+    }
+
+    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
+      };
+    }
+
+    if (currentPendingTransitionCallbacks.transitionComplete === null) {
+      currentPendingTransitionCallbacks.transitionComplete = [];
+    }
+
+    currentPendingTransitionCallbacks.transitionComplete.push(transition);
+  }
+}
 
 function resetRenderTimer() {
-  workInProgressRootRenderTargetTime = now() + RENDER_TIMEOUT_MS;
+  workInProgressRootRenderTargetTime = now$1() + RENDER_TIMEOUT_MS;
 }
 
 function getRenderTargetTime() {
@@ -34317,9 +38367,13 @@ function getRenderTargetTime() {
 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
 
@@ -34346,7 +38400,7 @@ function getWorkInProgressRootRenderLanes() {
 function requestEventTime() {
   if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
     // We're inside React, so it's fine to read the actual time.
-    return now();
+    return now$1();
   } // We're not inside React, so we may be in the middle of a browser event.
 
   if (currentEventTime !== NoTimestamp) {
@@ -34354,7 +38408,7 @@ function requestEventTime() {
     return currentEventTime;
   } // This is the first update since React yielded. Compute a new start time.
 
-  currentEventTime = now();
+  currentEventTime = now$1();
   return currentEventTime;
 }
 function requestUpdateLane(fiber) {
@@ -34364,6 +38418,7 @@ function requestUpdateLane(fiber) {
   if ((mode & ConcurrentMode) === NoMode) {
     return SyncLane;
   } else if (
+    !deferRenderPhaseUpdateToNextBatch &&
     (executionContext & RenderContext) !== NoContext &&
     workInProgressRootRenderLanes !== NoLanes
   ) {
@@ -34477,15 +38532,64 @@ function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
     // 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);
+      }
+    }
+
     warnIfUpdatesNotWrappedWithActDEV(fiber);
 
+    if (enableProfilerNestedUpdateScheduledHook) {
+      if (
+        (executionContext & CommitContext) !== NoContext &&
+        root === rootCommittingMutationOrLayoutEffects
+      ) {
+        if (fiber.mode & ProfileMode) {
+          var current = fiber;
+
+          while (current !== null) {
+            if (current.tag === Profiler) {
+              var _current$memoizedProp = current.memoizedProps,
+                id = _current$memoizedProp.id,
+                onNestedUpdateScheduled =
+                  _current$memoizedProp.onNestedUpdateScheduled;
+
+              if (typeof onNestedUpdateScheduled === "function") {
+                onNestedUpdateScheduled(id);
+              }
+            }
+
+            current = current.return;
+          }
+        }
+      }
+    }
+
+    if (enableTransitionTracing) {
+      var transition = ReactCurrentBatchConfig.transition;
+
+      if (transition !== null && transition.name != null) {
+        if (transition.startTime === -1) {
+          transition.startTime = now$1();
+        }
+
+        addTransitionToLanesMap(root, transition, lane);
+      }
+    }
+
     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 ((executionContext & RenderContext) === NoContext) {
+      if (
+        deferRenderPhaseUpdateToNextBatch ||
+        (executionContext & RenderContext) === NoContext
+      ) {
         workInProgressRootInterleavedUpdatedLanes = mergeLanes(
           workInProgressRootInterleavedUpdatedLanes,
           lane
@@ -34542,6 +38646,8 @@ function isUnsafeClassRenderPhaseUpdate(fiber) {
   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
@@ -34696,6 +38802,9 @@ function ensureRootIsScheduled(root, currentTime) {
 // goes through Scheduler.
 
 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.
 
   currentEventTime = NoTimestamp;
@@ -34739,7 +38848,7 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
   var shouldTimeSlice =
     !includesBlockingLane(root, lanes) &&
     !includesExpiredLane(root, lanes) &&
-    !didTimeout;
+    (disableSchedulerTimeoutInWorkLoop || !didTimeout);
   var exitStatus = shouldTimeSlice
     ? renderRootConcurrent(root, lanes)
     : renderRootSync(root, lanes);
@@ -34770,7 +38879,7 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
       var fatalError = workInProgressRootFatalError;
       prepareFreshStack(root, NoLanes);
       markRootSuspended(root, lanes);
-      ensureRootIsScheduled(root, now());
+      ensureRootIsScheduled(root, now$1());
       throw fatalError;
     }
 
@@ -34820,7 +38929,7 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
           var _fatalError = workInProgressRootFatalError;
           prepareFreshStack(root, NoLanes);
           markRootSuspended(root, lanes);
-          ensureRootIsScheduled(root, now());
+          ensureRootIsScheduled(root, now$1());
           throw _fatalError;
         } // FIXME: Need to check for RootDidNotComplete again. The factoring here
         // isn't ideal.
@@ -34833,7 +38942,7 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
     }
   }
 
-  ensureRootIsScheduled(root, now());
+  ensureRootIsScheduled(root, now$1());
 
   if (root.callbackNode === originalCallbackNode) {
     // The task node scheduled for this root is the same one that's
@@ -34962,7 +39071,7 @@ function finishConcurrentRender(root, exitStatus, lanes) {
         // 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(); // Don't bother with a very short suspense time.
+          globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now$1(); // Don't bother with a very short suspense time.
 
         if (msUntilTimeout > 10) {
           var nextLanes = getNextLanes(root, NoLanes);
@@ -35014,7 +39123,7 @@ function finishConcurrentRender(root, exitStatus, lanes) {
         // Consider removing.
         var mostRecentEventTime = getMostRecentEventTime(root, lanes);
         var eventTimeMs = mostRecentEventTime;
-        var timeElapsedMs = now() - eventTimeMs;
+        var timeElapsedMs = now$1() - eventTimeMs;
 
         var _msUntilTimeout = jnd(timeElapsedMs) - timeElapsedMs; // Don't bother with a very short suspense time.
 
@@ -35135,6 +39244,10 @@ function markRootSuspended(root, suspendedLanes) {
 // through Scheduler
 
 function performSyncWorkOnRoot(root) {
+  {
+    syncNestedUpdateFlag();
+  }
+
   if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
     throw new Error("Should not already be working.");
   }
@@ -35144,7 +39257,7 @@ function performSyncWorkOnRoot(root) {
 
   if (!includesSyncLane(lanes)) {
     // There's no remaining sync work left.
-    ensureRootIsScheduled(root, now());
+    ensureRootIsScheduled(root, now$1());
     return null;
   }
 
@@ -35175,7 +39288,7 @@ function performSyncWorkOnRoot(root) {
     var fatalError = workInProgressRootFatalError;
     prepareFreshStack(root, NoLanes);
     markRootSuspended(root, lanes);
-    ensureRootIsScheduled(root, now());
+    ensureRootIsScheduled(root, now$1());
     throw fatalError;
   }
 
@@ -35184,7 +39297,7 @@ function performSyncWorkOnRoot(root) {
     // cases where need to exit the current render without producing a
     // consistent tree or committing.
     markRootSuspended(root, lanes);
-    ensureRootIsScheduled(root, now());
+    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.
@@ -35199,14 +39312,14 @@ function performSyncWorkOnRoot(root) {
   ); // Before exiting, make sure there's a callback scheduled for the next
   // pending level.
 
-  ensureRootIsScheduled(root, now());
+  ensureRootIsScheduled(root, now$1());
   return null;
 }
 
 function flushRoot(root, lanes) {
   if (lanes !== NoLanes) {
     markRootEntangled(root, mergeLanes(lanes, SyncLane));
-    ensureRootIsScheduled(root, now());
+    ensureRootIsScheduled(root, now$1());
 
     if ((executionContext & (RenderContext | CommitContext)) === NoContext) {
       resetRenderTimer();
@@ -35214,6 +39327,9 @@ function flushRoot(root, lanes) {
     }
   }
 }
+function getExecutionContext() {
+  return executionContext;
+}
 function batchedUpdates(fn, a) {
   var prevExecutionContext = executionContext;
   executionContext |= BatchedContext;
@@ -35297,6 +39413,10 @@ function isAlreadyRendering() {
   // 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;
@@ -35460,6 +39580,41 @@ function handleThrow(root, thrownValue) {
     workInProgressRootFatalError = thrownValue;
     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);
+  }
+
+  if (enableSchedulingProfiler) {
+    markComponentRenderStopped();
+
+    switch (workInProgressSuspendedReason) {
+      case SuspendedOnError: {
+        markComponentErrored(
+          erroredWork,
+          thrownValue,
+          workInProgressRootRenderLanes
+        );
+        break;
+      }
+
+      case SuspendedOnData:
+      case SuspendedOnImmediate:
+      case SuspendedOnDeprecatedThrowPromise:
+      case SuspendedAndReadyToContinue: {
+        var wakeable = thrownValue;
+        markComponentSuspended(
+          erroredWork,
+          wakeable,
+          workInProgressRootRenderLanes
+        );
+        break;
+      }
+    }
+  }
 }
 
 function shouldAttemptToSuspendUntilDataResolves() {
@@ -35537,7 +39692,7 @@ function popCacheDispatcher(prevCacheDispatcher) {
 }
 
 function markCommitTimeOfFallback() {
-  globalMostRecentFallbackTime = now();
+  globalMostRecentFallbackTime = now$1();
 }
 function markSkippedUpdateLanes(lane) {
   workInProgressRootSkippedLanes = mergeLanes(
@@ -35601,10 +39756,36 @@ function renderRootSync(root, lanes) {
   // and prepare a fresh one. Otherwise we'll continue where we left off.
 
   if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    workInProgressTransitions = getTransitionsForLanes();
+    {
+      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.
+
+        movePendingFibersToMemoized(root, lanes);
+      }
+    }
+
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
     prepareFreshStack(root, lanes);
   }
 
+  {
+    if (enableDebugTracing) {
+      logRenderStarted(lanes);
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markRenderStarted(lanes);
+  }
+
   outer: do {
     try {
       if (
@@ -35662,6 +39843,16 @@ function renderRootSync(root, lanes) {
     );
   }
 
+  {
+    if (enableDebugTracing) {
+      logRenderStopped();
+    }
+  }
+
+  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.
 
@@ -35686,11 +39877,37 @@ function renderRootConcurrent(root, lanes) {
   // and prepare a fresh one. Otherwise we'll continue where we left off.
 
   if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes) {
-    workInProgressTransitions = getTransitionsForLanes();
+    {
+      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.
+
+        movePendingFibersToMemoized(root, lanes);
+      }
+    }
+
+    workInProgressTransitions = getTransitionsForLanes(root, lanes);
     resetRenderTimer();
     prepareFreshStack(root, lanes);
   }
 
+  {
+    if (enableDebugTracing) {
+      logRenderStarted(lanes);
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markRenderStarted(lanes);
+  }
+
   outer: do {
     try {
       if (
@@ -35739,7 +39956,7 @@ function renderRootConcurrent(root, lanes) {
               // currently working on a different root, so that we resume
               // rendering later.
 
-              ensureRootIsScheduled(root, now());
+              ensureRootIsScheduled(root, now$1());
             };
 
             thenable.then(onResolution, onResolution);
@@ -35822,9 +40039,25 @@ function renderRootConcurrent(root, lanes) {
   popCacheDispatcher(prevCacheDispatcher);
   executionContext = prevExecutionContext;
 
+  {
+    if (enableDebugTracing) {
+      logRenderStopped();
+    }
+  } // Check if the tree has completed.
+
   if (workInProgress !== null) {
+    // Still work remaining.
+    if (enableSchedulingProfiler) {
+      markRenderYielded();
+    }
+
     return RootInProgress;
   } else {
+    // Completed the tree.
+    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.
 
@@ -35851,7 +40084,11 @@ function performUnitOfWork(unitOfWork) {
   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);
   }
 
@@ -35876,6 +40113,11 @@ function replaySuspendedUnitOfWork(unitOfWork) {
   setCurrentFiber(unitOfWork);
   var next;
   setCurrentFiber(unitOfWork);
+  var isProfilingMode = (unitOfWork.mode & ProfileMode) !== NoMode;
+
+  if (isProfilingMode) {
+    startProfilerTimer(unitOfWork);
+  }
 
   switch (unitOfWork.tag) {
     case IndeterminateComponent: {
@@ -35938,6 +40180,10 @@ function replaySuspendedUnitOfWork(unitOfWork) {
       break;
     }
   }
+
+  if (isProfilingMode) {
+    stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
+  } // The begin phase finished successfully without suspending. Return to the
   // normal work loop.
 
   resetCurrentFiber();
@@ -36017,8 +40263,13 @@ function completeUnitOfWork(unitOfWork) {
       setCurrentFiber(completedWork);
       var next = void 0;
 
-      {
+      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.
+
+        stopProfilerTimerIfRunningAndRecordDelta(completedWork, false);
       }
 
       resetCurrentFiber();
@@ -36044,6 +40295,22 @@ function completeUnitOfWork(unitOfWork) {
         return;
       }
 
+      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;
+        }
+
+        completedWork.actualDuration = actualDuration;
+      }
+
       if (returnFiber !== null) {
         // Mark the parent fiber as incomplete and clear its subtree flags.
         returnFiber.flags |= Incomplete;
@@ -36124,7 +40391,27 @@ function commitRootImpl(
   var finishedWork = root.finishedWork;
   var lanes = root.finishedLanes;
 
+  {
+    if (enableDebugTracing) {
+      logCommitStarted(lanes);
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markCommitStarted(lanes);
+  }
+
   if (finishedWork === null) {
+    {
+      if (enableDebugTracing) {
+        logCommitStopped();
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markCommitStopped();
+    }
+
     return null;
   } else {
     {
@@ -36227,7 +40514,19 @@ function commitRootImpl(
       finishedWork
     );
 
-    commitMutationEffects(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 (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 (shouldFireAfterActiveInstanceBlur) {
@@ -36241,8 +40540,34 @@ function commitRootImpl(
     // 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.
 
-    commitLayoutEffects(finishedWork, root);
+    {
+      if (enableDebugTracing) {
+        logLayoutEffectsStarted(lanes);
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markLayoutEffectsStarted(lanes);
+    }
+
+    commitLayoutEffects(finishedWork, root, lanes);
+
+    {
+      if (enableDebugTracing) {
+        logLayoutEffectsStopped();
+      }
+    }
+
+    if (enableSchedulingProfiler) {
+      markLayoutEffectsStopped();
+    }
+
+    if (enableProfilerNestedUpdateScheduledHook) {
+      rootCommittingMutationOrLayoutEffects = null;
+    } // Tell Scheduler to yield at the end of the frame, so the browser has an
     // opportunity to paint.
 
     requestPaint();
@@ -36253,6 +40578,12 @@ function commitRootImpl(
   } 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();
+    }
   }
 
   var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;
@@ -36299,12 +40630,18 @@ function commitRootImpl(
 
   onCommitRoot$1(finishedWork.stateNode, renderPriorityLevel);
 
+  {
+    if (isDevToolsPresent) {
+      root.memoizedUpdaters.clear();
+    }
+  }
+
   {
     onCommitRoot();
   } // Always call this before exiting `commitRoot`, to ensure that any
   // additional work on this root is scheduled.
 
-  ensureRootIsScheduled(root, now());
+  ensureRootIsScheduled(root, now$1());
 
   if (recoverableErrors !== null) {
     // There were errors during this render, but recovered from them without
@@ -36342,6 +40679,9 @@ function commitRootImpl(
   remainingLanes = root.pendingLanes;
 
   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 (root === rootWithNestedUpdates) {
@@ -36356,6 +40696,48 @@ function commitRootImpl(
 
   flushSyncCallbacks();
 
+  {
+    if (enableDebugTracing) {
+      logCommitStopped();
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markCommitStopped();
+  }
+
+  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 (prevRootTransitionCallbacks !== null) {
+      schedulePostPaintCallback(function (endTime) {
+        var prevPendingTransitionCallbacks = currentPendingTransitionCallbacks;
+
+        if (prevPendingTransitionCallbacks !== null) {
+          currentPendingTransitionCallbacks = null;
+          scheduleCallback(IdlePriority, function () {
+            processTransitionCallbacks(
+              prevPendingTransitionCallbacks,
+              endTime,
+              prevRootTransitionCallbacks
+            );
+          });
+        } else {
+          currentEndTime = endTime;
+        }
+      });
+    }
+  }
+
   return null;
 }
 
@@ -36436,6 +40818,19 @@ function flushPassiveEffects() {
 
   return false;
 }
+function enqueuePendingPassiveProfilerEffect(fiber) {
+  {
+    pendingPassiveProfilerEffects.push(fiber);
+
+    if (!rootDoesHavePassiveEffects) {
+      rootDoesHavePassiveEffects = true;
+      scheduleCallback(NormalPriority$1, function () {
+        flushPassiveEffects();
+        return null;
+      });
+    }
+  }
+}
 
 function flushPassiveEffectsImpl() {
   if (rootWithPendingPassiveEffects === null) {
@@ -36459,6 +40854,14 @@ function flushPassiveEffectsImpl() {
   {
     isFlushingPassiveEffects = true;
     didScheduleUpdateDuringPassiveEffects = false;
+
+    if (enableDebugTracing) {
+      logPassiveEffectsStarted(lanes);
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markPassiveEffectsStarted(lanes);
   }
 
   var prevExecutionContext = executionContext;
@@ -36466,6 +40869,26 @@ function flushPassiveEffectsImpl() {
   commitPassiveUnmountEffects(root.current);
   commitPassiveMountEffects(root, root.current, lanes, transitions); // TODO: Move to commitPassiveMountEffects
 
+  {
+    var profilerEffects = pendingPassiveProfilerEffects;
+    pendingPassiveProfilerEffects = [];
+
+    for (var i = 0; i < profilerEffects.length; i++) {
+      var fiber = profilerEffects[i];
+      commitPassiveEffectDurations(root, fiber);
+    }
+  }
+
+  {
+    if (enableDebugTracing) {
+      logPassiveEffectsStopped();
+    }
+  }
+
+  if (enableSchedulingProfiler) {
+    markPassiveEffectsStopped();
+  }
+
   {
     commitDoubleInvokeEffectsInDEV(root, true);
   }
@@ -36473,6 +40896,28 @@ function flushPassiveEffectsImpl() {
   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
+        );
+      });
+    }
+  }
+
   {
     // If additional passive effects were scheduled, increment a counter. If this
     // exceeds the limit, we'll fire a warning.
@@ -36493,6 +40938,12 @@ function flushPassiveEffectsImpl() {
 
   onPostCommitRoot(root);
 
+  {
+    var stateNode = root.current.stateNode;
+    stateNode.effectDuration = 0;
+    stateNode.passiveEffectDuration = 0;
+  }
+
   return true;
 }
 
@@ -36546,8 +40997,10 @@ function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error$1) {
 
   var fiber = null;
 
-  {
+  if (skipUnmountedBoundaries) {
     fiber = nearestMountedAncestor;
+  } else {
+    fiber = sourceFiber.return;
   }
 
   while (fiber !== null) {
@@ -36631,6 +41084,13 @@ function attachPingListener(root, wakeable, lanes) {
     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);
+      }
+    }
+
     wakeable.then(ping, ping);
   }
 }
@@ -36663,7 +41123,7 @@ function pingSuspendedRoot(root, wakeable, pingedLanes) {
       workInProgressRootExitStatus === RootSuspendedWithDelay ||
       (workInProgressRootExitStatus === RootSuspended &&
         includesOnlyRetries(workInProgressRootRenderLanes) &&
-        now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS)
+        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.
@@ -36932,7 +41392,78 @@ function warnAboutUpdateOnNotYetMountedFiberInDEV(fiber) {
 }
 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
+
+      resetSuspendedWorkLoopOnUnwind();
+      unwindInterruptedWork(current, unitOfWork); // Restore the original properties of the fiber.
+
+      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.
+
+      throw originalError;
+    }
+  };
+} else {
   beginWork = beginWork$1;
 }
 
@@ -36991,6 +41522,19 @@ function warnAboutRenderPhaseUpdatesInDEV(fiber) {
     }
   }
 }
+
+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]
 
 function scheduleCallback(priorityLevel, callback) {
@@ -37604,6 +42148,32 @@ function FiberNode(tag, pendingProps, key, mode) {
   this.childLanes = NoLanes;
   this.alternate = 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).
+
+    this.actualDuration = 0;
+    this.actualStartTime = -1;
+    this.selfBaseDuration = 0;
+    this.treeBaseDuration = 0;
+  }
+
   {
     // This isn't directly used but is handy for debugging internals:
     this._debugSource = null;
@@ -37702,6 +42272,15 @@ function createWorkInProgress(current, pendingProps) {
 
     workInProgress.subtreeFlags = NoFlags$1;
     workInProgress.deletions = null;
+
+    {
+      // 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.
 
@@ -37728,6 +42307,11 @@ function createWorkInProgress(current, pendingProps) {
   workInProgress.ref = current.ref;
   workInProgress.refCleanup = current.refCleanup;
 
+  {
+    workInProgress.selfBaseDuration = current.selfBaseDuration;
+    workInProgress.treeBaseDuration = current.treeBaseDuration;
+  }
+
   {
     workInProgress._debugNeedsRemount = current._debugNeedsRemount;
 
@@ -37775,6 +42359,13 @@ function resetWorkInProgress(workInProgress, renderLanes) {
     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;
@@ -37797,6 +42388,13 @@ function resetWorkInProgress(workInProgress, renderLanes) {
             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 workInProgress;
@@ -37825,6 +42423,13 @@ function createHostRootFiber(
     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;
+  }
+
   return createFiber(HostRoot, null, null, mode);
 }
 function createFiberFromTypeAndProps(
@@ -37888,7 +42493,9 @@ function createFiberFromTypeAndProps(
       case REACT_OFFSCREEN_TYPE:
         return createFiberFromOffscreen(pendingProps, mode, lanes, key);
 
-      case REACT_LEGACY_HIDDEN_TYPE:
+      case REACT_LEGACY_HIDDEN_TYPE: {
+        return createFiberFromLegacyHidden(pendingProps, mode, lanes, key);
+      }
 
       // eslint-disable-next-line no-fallthrough
 
@@ -37905,10 +42512,18 @@ function createFiberFromTypeAndProps(
       // eslint-disable-next-line no-fallthrough
 
       case REACT_TRACING_MARKER_TYPE:
+        if (enableTransitionTracing) {
+          return createFiberFromTracingMarker(pendingProps, mode, lanes, key);
+        }
 
       // eslint-disable-next-line no-fallthrough
 
       case REACT_DEBUG_TRACING_MODE_TYPE:
+        if (enableDebugTracing) {
+          fiberTag = Mode;
+          mode |= DebugTracingMode;
+          break;
+        }
 
       // eslint-disable-next-line no-fallthrough
 
@@ -38040,6 +42655,13 @@ function createFiberFromProfiler(pendingProps, mode, lanes, key) {
   fiber.elementType = REACT_PROFILER_TYPE;
   fiber.lanes = lanes;
 
+  {
+    fiber.stateNode = {
+      effectDuration: 0,
+      passiveEffectDuration: 0
+    };
+  }
+
   return fiber;
 }
 
@@ -38076,12 +42698,49 @@ function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
   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;
@@ -38110,6 +42769,55 @@ function createFiberFromPortal(portal, mode, lanes) {
   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 FiberRootNode(
   containerInfo, // $FlowFixMe[missing-local-annot]
   tag,
@@ -38158,6 +42866,29 @@ function FiberRootNode(
 
   this.incompleteTransitions = new Map();
 
+  if (enableTransitionTracing) {
+    this.transitionCallbacks = null;
+    var transitionLanesMap = (this.transitionLanes = []);
+
+    for (var i = 0; i < TotalLanes; i++) {
+      transitionLanesMap.push(null);
+    }
+  }
+
+  {
+    this.effectDuration = 0;
+    this.passiveEffectDuration = 0;
+  }
+
+  {
+    this.memoizedUpdaters = new Set();
+    var pendingUpdatersLaneMap = (this.pendingUpdatersLaneMap = []);
+
+    for (var _i = 0; _i < TotalLanes; _i++) {
+      pendingUpdatersLaneMap.push(new Set());
+    }
+  }
+
   {
     switch (tag) {
       case ConcurrentRoot:
@@ -38198,6 +42929,10 @@ function createFiberRoot(
   {
     root.hydrationCallbacks = hydrationCallbacks;
   }
+
+  if (enableTransitionTracing) {
+    root.transitionCallbacks = transitionCallbacks;
+  } // Cyclic construction. This cheats the type system right now because
   // stateNode is any.
 
   var uninitializedFiber = createHostRootFiber(
@@ -38232,7 +42967,7 @@ function createFiberRoot(
   return root;
 }
 
-var ReactVersion = "18.3.0-www-modern-067984be";
+var ReactVersion = "18.3.0-www-modern-8bfe57ba";
 
 function createPortal$1(
   children,
@@ -38304,7 +43039,8 @@ function createContainer(
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   );
 }
 function createHydrationContainer(
@@ -38329,7 +43065,8 @@ function createHydrationContainer(
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   ); // TODO: Move this to FiberRoot constructor
 
   root.context = getContextForSubtree(null); // Schedule the initial render. In a hydration root, this is different from
@@ -38357,6 +43094,10 @@ function updateContainer(element, container, parentComponent, callback) {
   var current$1 = container.current;
   var lane = requestUpdateLane(current$1);
 
+  if (enableSchedulingProfiler) {
+    markRenderScheduled(lane);
+  }
+
   var context = getContextForSubtree(parentComponent);
 
   if (container.context === null) {
@@ -38463,6 +43204,26 @@ function markRetryLaneIfNotHydrated(fiber, retryLane) {
     markRetryLaneImpl(alternate, retryLane);
   }
 }
+
+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;
+  }
+
+  var lane = SyncLane;
+  var root = enqueueConcurrentRenderForLane(fiber, lane);
+
+  if (root !== null) {
+    var eventTime = requestEventTime();
+    scheduleUpdateOnFiber(root, fiber, lane, eventTime);
+  }
+
+  markRetryLaneIfNotHydrated(fiber, lane);
+}
 function attemptContinuousHydration(fiber) {
   if (fiber.tag !== SuspenseComponent) {
     // We ignore HostRoots here because we can't increase
@@ -38890,6 +43651,7 @@ function createRoot$1(container, options) {
   var concurrentUpdatesByDefaultOverride = false;
   var identifierPrefix = "";
   var onRecoverableError = defaultOnRecoverableError;
+  var transitionCallbacks = null;
 
   if (options !== null && options !== undefined) {
     {
@@ -38929,6 +43691,10 @@ function createRoot$1(container, options) {
     if (options.onRecoverableError !== undefined) {
       onRecoverableError = options.onRecoverableError;
     }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
   }
 
   var root = createContainer(
@@ -38938,7 +43704,8 @@ function createRoot$1(container, options) {
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   );
   markContainerAsRoot(root.current, container);
 
@@ -38989,6 +43756,7 @@ function hydrateRoot$1(container, initialChildren, options) {
   var concurrentUpdatesByDefaultOverride = false;
   var identifierPrefix = "";
   var onRecoverableError = defaultOnRecoverableError;
+  var transitionCallbacks = null;
 
   if (options !== null && options !== undefined) {
     if (options.unstable_strictMode === true) {
@@ -39006,6 +43774,10 @@ function hydrateRoot$1(container, initialChildren, options) {
     if (options.onRecoverableError !== undefined) {
       onRecoverableError = options.onRecoverableError;
     }
+
+    if (options.unstable_transitionCallbacks !== undefined) {
+      transitionCallbacks = options.unstable_transitionCallbacks;
+    }
   }
 
   var root = createHydrationContainer(
@@ -39017,7 +43789,8 @@ function hydrateRoot$1(container, initialChildren, options) {
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   );
   markContainerAsRoot(root.current, container);
 
@@ -39043,7 +43816,8 @@ function isValidContainer(node) {
     (node.nodeType === ELEMENT_NODE ||
       node.nodeType === DOCUMENT_NODE ||
       node.nodeType === DOCUMENT_FRAGMENT_NODE ||
-      !disableCommentsAsDOMContainers)
+      (node.nodeType === COMMENT_NODE &&
+        node.nodeValue === " react-mount-point-unstable "))
   );
 } // TODO: Remove this function which also includes comment nodes.
 
@@ -39205,6 +43979,7 @@ function preinit() {
 }
 
 setAttemptSynchronousHydration(attemptSynchronousHydration);
+setAttemptDiscreteHydration(attemptDiscreteHydration);
 setAttemptContinuousHydration(attemptContinuousHydration);
 setAttemptHydrationAtCurrentPriority(attemptHydrationAtCurrentPriority);
 setGetCurrentUpdatePriority(getCurrentUpdatePriority$1);
diff --git a/compiled/facebook-www/ReactDOMTesting-prod.classic.js b/compiled/facebook-www/ReactDOMTesting-prod.classic.js
index 629401d89718e..9b07d252c5e78 100644
--- a/compiled/facebook-www/ReactDOMTesting-prod.classic.js
+++ b/compiled/facebook-www/ReactDOMTesting-prod.classic.js
@@ -16,7 +16,32 @@
 "use strict";
 var Scheduler = require("scheduler"),
   React = require("react"),
-  assign = Object.assign;
+  assign = Object.assign,
+  dynamicFeatureFlags = require("ReactFeatureFlags"),
+  disableInputAttributeSyncing =
+    dynamicFeatureFlags.disableInputAttributeSyncing,
+  enableTrustedTypesIntegration =
+    dynamicFeatureFlags.enableTrustedTypesIntegration,
+  enableFilterEmptyStringAttributesDOM =
+    dynamicFeatureFlags.enableFilterEmptyStringAttributesDOM,
+  enableLegacyFBSupport = dynamicFeatureFlags.enableLegacyFBSupport,
+  deferRenderPhaseUpdateToNextBatch =
+    dynamicFeatureFlags.deferRenderPhaseUpdateToNextBatch,
+  enableDebugTracing = dynamicFeatureFlags.enableDebugTracing,
+  skipUnmountedBoundaries = dynamicFeatureFlags.skipUnmountedBoundaries,
+  enableUseRefAccessWarning = dynamicFeatureFlags.enableUseRefAccessWarning,
+  disableNativeComponentFrames =
+    dynamicFeatureFlags.disableNativeComponentFrames,
+  disableSchedulerTimeoutInWorkLoop =
+    dynamicFeatureFlags.disableSchedulerTimeoutInWorkLoop,
+  enableLazyContextPropagation =
+    dynamicFeatureFlags.enableLazyContextPropagation,
+  enableUnifiedSyncLane = dynamicFeatureFlags.enableUnifiedSyncLane,
+  enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay =
+    dynamicFeatureFlags.enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay,
+  enableTransitionTracing = dynamicFeatureFlags.enableTransitionTracing,
+  enableCustomElementPropertySupport =
+    dynamicFeatureFlags.enableCustomElementPropertySupport;
 function formatProdErrorMessage(code) {
   for (
     var url = "https://reactjs.org/docs/error-decoder.html?invariant=" + code,
@@ -48,15 +73,16 @@ var ReactSharedInternals =
   REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
   REACT_MEMO_TYPE = Symbol.for("react.memo"),
   REACT_LAZY_TYPE = Symbol.for("react.lazy"),
-  REACT_SCOPE_TYPE = Symbol.for("react.scope");
-Symbol.for("react.debug_trace_mode");
-var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"),
+  REACT_SCOPE_TYPE = Symbol.for("react.scope"),
+  REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for("react.debug_trace_mode"),
+  REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"),
   REACT_LEGACY_HIDDEN_TYPE = Symbol.for("react.legacy_hidden"),
-  REACT_CACHE_TYPE = Symbol.for("react.cache");
-Symbol.for("react.tracing_marker");
-var REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for(
+  REACT_CACHE_TYPE = Symbol.for("react.cache"),
+  REACT_TRACING_MARKER_TYPE = Symbol.for("react.tracing_marker"),
+  REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for(
     "react.default_value"
   ),
+  REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel"),
   MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
 function getIteratorFn(maybeIterable) {
   if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
@@ -84,6 +110,8 @@ function getComponentNameFromType(type) {
       return "SuspenseList";
     case REACT_CACHE_TYPE:
       return "Cache";
+    case REACT_TRACING_MARKER_TYPE:
+      if (enableTransitionTracing) return "TracingMarker";
   }
   if ("object" === typeof type)
     switch (type.$$typeof) {
@@ -173,6 +201,9 @@ function getComponentNameFromFiber(fiber) {
       if ("function" === typeof type)
         return type.displayName || type.name || null;
       if ("string" === typeof type) return type;
+      break;
+    case 23:
+      return "LegacyHidden";
   }
   return null;
 }
@@ -473,8 +504,15 @@ function shouldRemoveAttribute(
     )
   )
     return !0;
-  if (isCustomComponentTag) return !1;
-  if (null !== propertyInfo)
+  if (isCustomComponentTag)
+    return enableCustomElementPropertySupport && !1 === value ? !0 : !1;
+  if (null !== propertyInfo) {
+    if (
+      enableFilterEmptyStringAttributesDOM &&
+      propertyInfo.removeEmptyString &&
+      "" === value
+    )
+      return !0;
     switch (propertyInfo.type) {
       case 3:
         return !value;
@@ -485,6 +523,7 @@ function shouldRemoveAttribute(
       case 6:
         return isNaN(value) || 1 > value;
     }
+  }
   return !1;
 }
 function PropertyInfoRecord(
@@ -505,12 +544,16 @@ function PropertyInfoRecord(
   this.sanitizeURL = sanitizeURL;
   this.removeEmptyString = removeEmptyString;
 }
-var properties = {};
-"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style"
-  .split(" ")
-  .forEach(function (name) {
-    properties[name] = new PropertyInfoRecord(name, 0, !1, name, null, !1, !1);
-  });
+var properties = {},
+  reservedProps =
+    "children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(
+      " "
+    );
+enableCustomElementPropertySupport &&
+  reservedProps.push("innerText", "textContent");
+reservedProps.forEach(function (name) {
+  properties[name] = new PropertyInfoRecord(name, 0, !1, name, null, !1, !1);
+});
 [
   ["acceptCharset", "accept-charset"],
   ["className", "class"],
@@ -671,20 +714,56 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
         !(2 < name.length) ||
         ("o" !== name[0] && "O" !== name[0]) ||
         ("n" !== name[1] && "N" !== name[1])
-  )
+  ) {
+    if (
+      enableCustomElementPropertySupport &&
+      isCustomComponentTag &&
+      "o" === name[0] &&
+      "n" === name[1]
+    ) {
+      var eventName = name.replace(/Capture$/, ""),
+        useCapture = name !== eventName;
+      eventName = eventName.slice(2);
+      var prevProps = getFiberCurrentPropsFromNode(node);
+      prevProps = null != prevProps ? prevProps[name] : null;
+      "function" === typeof prevProps &&
+        node.removeEventListener(eventName, prevProps, useCapture);
+      if ("function" === typeof value) {
+        "function" !== typeof prevProps &&
+          null !== prevProps &&
+          (name in node
+            ? (node[name] = null)
+            : node.hasAttribute(name) && node.removeAttribute(name));
+        node.addEventListener(eventName, value, useCapture);
+        return;
+      }
+    }
     if (
+      enableCustomElementPropertySupport &&
+      isCustomComponentTag &&
+      name in node
+    )
+      node[name] = value;
+    else if (
       (shouldRemoveAttribute(
         name,
         value,
         JSCompiler_inline_result,
         isCustomComponentTag
       ) && (value = null),
+      enableCustomElementPropertySupport &&
+        isCustomComponentTag &&
+        !0 === value &&
+        (value = ""),
       isCustomComponentTag || null === JSCompiler_inline_result)
     )
       isAttributeNameSafe(name) &&
         (null === value
           ? node.removeAttribute(name)
-          : node.setAttribute(name, "" + value));
+          : node.setAttribute(
+              name,
+              enableTrustedTypesIntegration ? value : "" + value
+            ));
     else if (JSCompiler_inline_result.mustUseProperty)
       node[JSCompiler_inline_result.propertyName] =
         null === value
@@ -699,10 +778,10 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
     )
       node.removeAttribute(name);
     else {
-      var type$3 = JSCompiler_inline_result.type;
-      if (3 === type$3 || (4 === type$3 && !0 === value)) value = "";
+      eventName = JSCompiler_inline_result.type;
+      if (3 === eventName || (4 === eventName && !0 === value)) value = "";
       else if (
-        ((value = "" + value),
+        ((value = enableTrustedTypesIntegration ? value : "" + value),
         JSCompiler_inline_result.sanitizeURL &&
           isJavaScriptProtocol.test(value.toString()))
       )
@@ -711,6 +790,7 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
         ? node.setAttributeNS(isCustomComponentTag, name, value)
         : node.setAttribute(name, value);
     }
+  }
 }
 var prefix;
 function describeBuiltInComponentFrame(name) {
@@ -725,7 +805,7 @@ function describeBuiltInComponentFrame(name) {
 }
 var reentry = !1;
 function describeNativeComponentFrame(fn, construct) {
-  if (!fn || reentry) return "";
+  if (disableNativeComponentFrames || !fn || reentry) return "";
   reentry = !0;
   var previousPrepareStackTrace = Error.prepareStackTrace;
   Error.prepareStackTrace = void 0;
@@ -956,7 +1036,10 @@ function updateWrapper$1(element, props) {
     element.removeAttribute("value");
     return;
   }
-  props.hasOwnProperty("value")
+  disableInputAttributeSyncing
+    ? props.hasOwnProperty("defaultValue") &&
+      setDefaultValue(element, props.type, getToStringValue(props.defaultValue))
+    : props.hasOwnProperty("value")
     ? setDefaultValue(element, props.type, value)
     : props.hasOwnProperty("defaultValue") &&
       setDefaultValue(
@@ -964,28 +1047,44 @@ function updateWrapper$1(element, props) {
         props.type,
         getToStringValue(props.defaultValue)
       );
-  null == props.checked &&
-    null != props.defaultChecked &&
-    (element.defaultChecked = !!props.defaultChecked);
+  disableInputAttributeSyncing
+    ? null == props.defaultChecked
+      ? element.removeAttribute("checked")
+      : (element.defaultChecked = !!props.defaultChecked)
+    : null == props.checked &&
+      null != props.defaultChecked &&
+      (element.defaultChecked = !!props.defaultChecked);
 }
 function postMountWrapper$3(element, props, isHydrating) {
   if (props.hasOwnProperty("value") || props.hasOwnProperty("defaultValue")) {
     var type = props.type;
     if (
-      !(
-        ("submit" !== type && "reset" !== type) ||
-        (void 0 !== props.value && null !== props.value)
-      )
+      (type = "submit" === type || "reset" === type) &&
+      (void 0 === props.value || null === props.value)
     )
       return;
-    props = "" + element._wrapperState.initialValue;
-    isHydrating || props === element.value || (element.value = props);
-    element.defaultValue = props;
+    var initialValue = "" + element._wrapperState.initialValue;
+    if (!isHydrating)
+      if (disableInputAttributeSyncing) {
+        var value = getToStringValue(props.value);
+        null == value ||
+          (!type && value === element.value) ||
+          (element.value = "" + value);
+      } else initialValue !== element.value && (element.value = initialValue);
+    disableInputAttributeSyncing
+      ? ((type = getToStringValue(props.defaultValue)),
+        null != type && (element.defaultValue = "" + type))
+      : (element.defaultValue = initialValue);
   }
-  isHydrating = element.name;
-  "" !== isHydrating && (element.name = "");
-  element.defaultChecked = !!element._wrapperState.initialChecked;
-  "" !== isHydrating && (element.name = isHydrating);
+  type = element.name;
+  "" !== type && (element.name = "");
+  disableInputAttributeSyncing
+    ? (isHydrating || updateChecked(element, props),
+      props.hasOwnProperty("defaultChecked") &&
+        ((element.defaultChecked = !element.defaultChecked),
+        (element.defaultChecked = !!props.defaultChecked)))
+    : (element.defaultChecked = !!element._wrapperState.initialChecked);
+  "" !== type && (element.name = type);
 }
 function setDefaultValue(node, type, value) {
   if ("number" !== type || getActiveElement(node.ownerDocument) !== node)
@@ -1266,14 +1365,6 @@ function normalizeMarkupForTextOrAttribute(markup) {
     .replace(NORMALIZE_NEWLINES_REGEX, "\n")
     .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
 }
-function checkForUnmatchedText(serverText, clientText, isConcurrentMode) {
-  clientText = normalizeMarkupForTextOrAttribute(clientText);
-  if (
-    normalizeMarkupForTextOrAttribute(serverText) !== clientText &&
-    isConcurrentMode
-  )
-    throw Error(formatProdErrorMessage(425));
-}
 function getOwnerDocumentFromRootContainer(rootContainerElement) {
   return 9 === rootContainerElement.nodeType
     ? rootContainerElement
@@ -1663,6 +1754,10 @@ function clz32Fallback(x) {
 var nextTransitionLane = 128,
   nextRetryLane = 8388608;
 function getHighestPriorityLanes(lanes) {
+  if (enableUnifiedSyncLane) {
+    var pendingSyncLanes = lanes & 42;
+    if (0 !== pendingSyncLanes) return pendingSyncLanes;
+  }
   switch (lanes & -lanes) {
     case 1:
       return 1;
@@ -1882,6 +1977,30 @@ function markRootEntangled(root, entangledLanes) {
     rootEntangledLanes &= ~lane;
   }
 }
+function getTransitionsForLanes(root, lanes) {
+  if (!enableTransitionTracing) return null;
+  for (var transitionsForLanes = []; 0 < lanes; ) {
+    var index$17 = 31 - clz32(lanes),
+      lane = 1 << index$17;
+    index$17 = root.transitionLanes[index$17];
+    null !== index$17 &&
+      index$17.forEach(function (transition) {
+        transitionsForLanes.push(transition);
+      });
+    lanes &= ~lane;
+  }
+  return 0 === transitionsForLanes.length ? null : transitionsForLanes;
+}
+function clearTransitionsForLanes(root, lanes) {
+  if (enableTransitionTracing)
+    for (; 0 < lanes; ) {
+      var index$18 = 31 - clz32(lanes),
+        lane = 1 << index$18;
+      null !== root.transitionLanes[index$18] &&
+        (root.transitionLanes[index$18] = null);
+      lanes &= ~lane;
+    }
+}
 var currentUpdatePriority = 0;
 function runWithPriority(priority, fn) {
   var previousPriority = currentUpdatePriority;
@@ -2263,7 +2382,6 @@ function prepareToHydrateHostInstance(fiber) {
     props = fiber.memoizedProps;
   instance[internalInstanceKey] = fiber;
   instance[internalPropsKey] = props;
-  var isConcurrentMode = 0 !== (fiber.mode & 1);
   switch (type) {
     case "dialog":
       listenToNonDelegatedEvent("cancel", instance);
@@ -2304,34 +2422,30 @@ function prepareToHydrateHostInstance(fiber) {
         listenToNonDelegatedEvent("invalid", instance);
   }
   assertValidProps(type, props);
-  i = null;
-  for (var propKey in props)
-    if (props.hasOwnProperty(propKey)) {
-      var nextProp = props[propKey];
+  var updatePayload = null,
+    propKey;
+  for (propKey in props)
+    props.hasOwnProperty(propKey) &&
+      ((i = props[propKey]),
       "children" === propKey
-        ? "string" === typeof nextProp
-          ? instance.textContent !== nextProp &&
+        ? "string" === typeof i
+          ? instance.textContent !== i &&
             (!0 !== props.suppressHydrationWarning &&
-              checkForUnmatchedText(
-                instance.textContent,
-                nextProp,
-                isConcurrentMode
-              ),
-            (i = ["children", nextProp]))
-          : "number" === typeof nextProp &&
-            instance.textContent !== "" + nextProp &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", i]))
+          : "number" === typeof i &&
+            instance.textContent !== "" + i &&
             (!0 !== props.suppressHydrationWarning &&
-              checkForUnmatchedText(
-                instance.textContent,
-                nextProp,
-                isConcurrentMode
-              ),
-            (i = ["children", "" + nextProp]))
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", "" + i]))
         : registrationNameDependencies.hasOwnProperty(propKey) &&
-          null != nextProp &&
+          null != i &&
           "onScroll" === propKey &&
-          listenToNonDelegatedEvent("scroll", instance);
-    }
+          listenToNonDelegatedEvent("scroll", instance));
   switch (type) {
     case "input":
       track(instance);
@@ -2347,7 +2461,7 @@ function prepareToHydrateHostInstance(fiber) {
     default:
       "function" === typeof props.onClick && (instance.onclick = noop$1);
   }
-  instance = i;
+  instance = updatePayload;
   fiber.updateQueue = instance;
   return null !== instance ? !0 : !1;
 }
@@ -2530,18 +2644,22 @@ function enqueueUpdate(fiber, update, lane) {
   var updateQueue = fiber.updateQueue;
   if (null === updateQueue) return null;
   updateQueue = updateQueue.shared;
-  if (0 !== (executionContext & 2)) {
-    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;
-  }
-  enqueueUpdate$1(fiber, updateQueue, update, lane);
-  return getRootForUpdatedFiber(fiber);
+  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;
@@ -3685,19 +3803,19 @@ function renderWithHooks(
       ? HooksDispatcherOnMount
       : HooksDispatcherOnUpdate;
   shouldDoubleInvokeUserFnsInHooksDEV = !1;
-  current = Component(props, secondArg);
+  nextRenderLanes = Component(props, secondArg);
   shouldDoubleInvokeUserFnsInHooksDEV = !1;
   didScheduleRenderPhaseUpdateDuringThisPass &&
-    (current = renderWithHooksAgain(
+    (nextRenderLanes = renderWithHooksAgain(
       workInProgress,
       Component,
       props,
       secondArg
     ));
-  finishRenderingHooks();
-  return current;
+  finishRenderingHooks(current);
+  return nextRenderLanes;
 }
-function finishRenderingHooks() {
+function finishRenderingHooks(current) {
   ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
   var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
   renderLanes$1 = 0;
@@ -3706,6 +3824,13 @@ function finishRenderingHooks() {
   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;
@@ -3796,15 +3921,15 @@ function updateWorkInProgressHook() {
 }
 var createFunctionComponentUpdateQueue;
 createFunctionComponentUpdateQueue = function () {
-  return { lastEffect: null, events: null, stores: null };
+  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$42 = thenableIndexCounter;
+      var index$46 = thenableIndexCounter;
       thenableIndexCounter += 1;
       null === thenableState && (thenableState = []);
-      usable = trackUsedThenable(thenableState, usable, index$42);
+      usable = trackUsedThenable(thenableState, usable, index$46);
       null === currentlyRenderingFiber$1.alternate &&
         (null === workInProgressHook
           ? null === currentlyRenderingFiber$1.memoizedState
@@ -3820,6 +3945,40 @@ function use(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;
 }
@@ -4145,6 +4304,28 @@ function mountEffect(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);
 }
@@ -4207,13 +4388,18 @@ function updateDeferredValueImpl(hook, prevValue, value) {
     (hook.baseState = !0));
   return prevValue;
 }
-function startTransition(setPending, callback) {
+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 {
@@ -4234,16 +4420,16 @@ function refreshCache(fiber, seedKey, seedValue) {
       case 3:
         var lane = requestUpdateLane(provider);
         fiber = createUpdate(lane);
-        var root$47 = enqueueUpdate(provider, fiber, lane);
-        if (null !== root$47) {
+        var root$52 = enqueueUpdate(provider, fiber, lane);
+        if (null !== root$52) {
           var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root$47, provider, lane, eventTime);
-          entangleTransitions(root$47, provider, lane);
+          scheduleUpdateOnFiber(root$52, provider, lane, eventTime);
+          entangleTransitions(root$52, provider, lane);
         }
         provider = createCache();
         null !== seedKey &&
           void 0 !== seedKey &&
-          null !== root$47 &&
+          null !== root$52 &&
           provider.data.set(seedKey, seedValue);
         fiber.payload = { cache: provider };
         return;
@@ -4355,6 +4541,8 @@ var ContextOnlyDispatcher = {
 };
 ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
 ContextOnlyDispatcher.use = throwInvalidHookError;
+ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
 var HooksDispatcherOnMount = {
   readContext: readContext,
   useCallback: function (callback, deps) {
@@ -4410,6 +4598,11 @@ var HooksDispatcherOnMount = {
   },
   useRef: function (initialValue) {
     var hook = mountWorkInProgressHook();
+    if (enableUseRefAccessWarning)
+      return (
+        (initialValue = { current: initialValue }),
+        (hook.memoizedState = initialValue)
+      );
     initialValue = { current: initialValue };
     return (hook.memoizedState = initialValue);
   },
@@ -4443,15 +4636,15 @@ var HooksDispatcherOnMount = {
       getServerSnapshot = getServerSnapshot();
     } else {
       getServerSnapshot = getSnapshot();
-      var root$44 = workInProgressRoot;
-      if (null === root$44) throw Error(formatProdErrorMessage(349));
-      includesBlockingLane(root$44, renderLanes$1) ||
+      var root$48 = workInProgressRoot;
+      if (null === root$48) throw Error(formatProdErrorMessage(349));
+      includesBlockingLane(root$48, renderLanes$1) ||
         pushStoreConsistencyCheck(fiber, getSnapshot, getServerSnapshot);
     }
     hook.memoizedState = getServerSnapshot;
-    root$44 = { value: getServerSnapshot, getSnapshot: getSnapshot };
-    hook.queue = root$44;
-    mountEffect(subscribeToStore.bind(null, fiber, root$44, subscribe), [
+    root$48 = { value: getServerSnapshot, getSnapshot: getSnapshot };
+    hook.queue = root$48;
+    mountEffect(subscribeToStore.bind(null, fiber, root$48, subscribe), [
       subscribe
     ]);
     fiber.flags |= 2048;
@@ -4460,7 +4653,7 @@ var HooksDispatcherOnMount = {
       updateStoreInstance.bind(
         null,
         fiber,
-        root$44,
+        root$48,
         getServerSnapshot,
         getSnapshot
       ),
@@ -4503,6 +4696,16 @@ var HooksDispatcherOnMount = {
   }
 };
 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,
@@ -4532,7 +4735,9 @@ var HooksDispatcherOnUpdate = {
   useId: updateId
 };
 HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
+HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
 HooksDispatcherOnUpdate.use = use;
+HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
 var HooksDispatcherOnRerender = {
   readContext: readContext,
   useCallback: updateCallback,
@@ -4565,6 +4770,8 @@ var HooksDispatcherOnRerender = {
 };
 HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
 HooksDispatcherOnRerender.use = use;
+HooksDispatcherOnRerender.useMemoCache = useMemoCache;
+HooksDispatcherOnRerender.useEffectEvent = updateEvent;
 function resolveDefaultProps(Component, baseProps) {
   if (Component && Component.defaultProps) {
     baseProps = assign({}, baseProps);
@@ -4838,6 +5045,143 @@ function markSuspenseBoundaryShouldCapture(
   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$62 = workInProgress.stateNode;
+    null !== transitions &&
+      transitions.forEach(function (transition) {
+        if (!root$62.incompleteTransitions.has(transition)) {
+          var markerInstance = {
+            tag: 0,
+            transitions: new Set([transition]),
+            pendingBoundaries: null,
+            aborts: null,
+            name: null
+          };
+          root$62.incompleteTransitions.set(transition, markerInstance);
+        }
+      });
+    var markerInstances = [];
+    root$62.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;
@@ -4921,7 +5265,7 @@ function updateMemoComponent(
     return (workInProgress.child = current);
   }
   type = current.child;
-  if (0 === (current.lanes & renderLanes)) {
+  if (!checkScheduledUpdateOrContext(current, renderLanes)) {
     var prevProps = type.memoizedProps;
     Component = Component.compare;
     Component = null !== Component ? Component : shallowEqual;
@@ -4950,7 +5294,7 @@ function updateSimpleMemoComponent(
       if (
         ((didReceiveUpdate = !1),
         (workInProgress.pendingProps = nextProps = prevProps),
-        0 !== (current.lanes & renderLanes))
+        checkScheduledUpdateOrContext(current, renderLanes))
       )
         0 !== (current.flags & 131072) && (didReceiveUpdate = !0);
       else
@@ -4973,27 +5317,31 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
     nextIsDetached = 0 !== (workInProgress.stateNode._pendingVisibility & 2),
     prevState = null !== current ? current.memoizedState : null;
   markRef$1(current, workInProgress);
-  if ("hidden" === nextProps.mode || nextIsDetached) {
+  if (
+    "hidden" === nextProps.mode ||
+    "unstable-defer-without-hiding" === nextProps.mode ||
+    nextIsDetached
+  ) {
     if (0 !== (workInProgress.flags & 128)) {
-      renderLanes =
+      nextChildren =
         null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
       if (null !== current) {
-        nextProps = workInProgress.child = current.child;
-        for (nextChildren = 0; null !== nextProps; )
-          (nextChildren =
-            nextChildren | nextProps.lanes | nextProps.childLanes),
-            (nextProps = nextProps.sibling);
-        workInProgress.childLanes = nextChildren & ~renderLanes;
+        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 !== current && pushTransition(workInProgress, null, null),
         reuseHiddenContextOnStack(),
         pushOffscreenSuspenseHandler(workInProgress);
     else if (0 !== (renderLanes & 1073741824))
@@ -5001,7 +5349,8 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         null !== current &&
           pushTransition(
             workInProgress,
-            null !== prevState ? prevState.cachePool : null
+            null !== prevState ? prevState.cachePool : null,
+            null
           ),
         null !== prevState
           ? pushHiddenContext(workInProgress, prevState)
@@ -5013,22 +5362,36 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         deferHiddenOffscreenComponent(
           current,
           workInProgress,
-          null !== prevState ? prevState.baseLanes | renderLanes : renderLanes
+          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 !== prevState
-      ? (pushTransition(workInProgress, prevState.cachePool),
-        pushHiddenContext(workInProgress, prevState),
-        reuseSuspenseHandlerOnStack(),
-        (workInProgress.memoizedState = null))
-      : (null !== current && pushTransition(workInProgress, null),
-        reuseHiddenContextOnStack(),
-        reuseSuspenseHandlerOnStack());
+    null !== current && pushTransition(workInProgress, null, null),
+      reuseHiddenContextOnStack(),
+      reuseSuspenseHandlerOnStack();
   reconcileChildren(current, workInProgress, nextChildren, renderLanes);
   return workInProgress.child;
 }
-function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes) {
+function deferHiddenOffscreenComponent(
+  current,
+  workInProgress,
+  nextBaseLanes,
+  renderLanes
+) {
   var JSCompiler_inline_result = peekCacheFromPool();
   JSCompiler_inline_result =
     null === JSCompiler_inline_result
@@ -5038,9 +5401,12 @@ function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes) {
     baseLanes: nextBaseLanes,
     cachePool: JSCompiler_inline_result
   };
-  null !== current && pushTransition(workInProgress, null);
+  null !== current && pushTransition(workInProgress, null, null);
   reuseHiddenContextOnStack();
   pushOffscreenSuspenseHandler(workInProgress);
+  enableLazyContextPropagation &&
+    null !== current &&
+    propagateParentContextChanges(current, workInProgress, renderLanes, !0);
   return null;
 }
 function markRef$1(current, workInProgress) {
@@ -5100,7 +5466,7 @@ function replayFunctionComponent(
     nextProps,
     context
   );
-  finishRenderingHooks();
+  finishRenderingHooks(current);
   Component = checkDidRenderIdHook();
   if (null !== current && !didReceiveUpdate)
     return (
@@ -5242,7 +5608,11 @@ function updateClassComponent(
     oldProps !== hasNewLifecycles ||
     oldState !== newState ||
     didPerformWorkStackCursor.current ||
-    hasForceUpdate
+    hasForceUpdate ||
+    (enableLazyContextPropagation &&
+      null !== current &&
+      null !== current.dependencies &&
+      checkIfContextChanged(current.dependencies))
       ? ("function" === typeof getDerivedStateFromProps$jscomp$0 &&
           (applyDerivedStateFromProps(
             workInProgress,
@@ -5262,7 +5632,10 @@ function updateClassComponent(
             newState,
             oldContext
           ) ||
-          !1)
+          (enableLazyContextPropagation &&
+            null !== current &&
+            null !== current.dependencies &&
+            checkIfContextChanged(current.dependencies)))
           ? (getDerivedStateFromProps ||
               ("function" !== typeof instance.UNSAFE_componentWillUpdate &&
                 "function" !== typeof instance.componentWillUpdate) ||
@@ -5452,9 +5825,26 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
           didSuspend,
           renderLanes
         )),
-        (workInProgress.child.memoizedState =
-          mountSuspenseOffscreenState(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)
@@ -5477,14 +5867,14 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
   }
   JSCompiler_temp = current.memoizedState;
   if (null !== JSCompiler_temp) {
-    var dehydrated$63 = JSCompiler_temp.dehydrated;
-    if (null !== dehydrated$63)
+    var dehydrated$69 = JSCompiler_temp.dehydrated;
+    if (null !== dehydrated$69)
       return updateDehydratedSuspenseComponent(
         current,
         workInProgress,
         didSuspend,
         nextProps,
-        dehydrated$63,
+        dehydrated$69,
         JSCompiler_temp,
         renderLanes
       );
@@ -5494,7 +5884,7 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
     showFallback = nextProps.fallback;
     didSuspend = workInProgress.mode;
     JSCompiler_temp = current.child;
-    dehydrated$63 = JSCompiler_temp.sibling;
+    dehydrated$69 = JSCompiler_temp.sibling;
     var primaryChildProps = { mode: "hidden", children: nextProps.children };
     0 === (didSuspend & 1) && workInProgress.child !== JSCompiler_temp
       ? ((nextProps = workInProgress.child),
@@ -5503,8 +5893,8 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
         (workInProgress.deletions = null))
       : ((nextProps = createWorkInProgress(JSCompiler_temp, primaryChildProps)),
         (nextProps.subtreeFlags = JSCompiler_temp.subtreeFlags & 14680064));
-    null !== dehydrated$63
-      ? (showFallback = createWorkInProgress(dehydrated$63, showFallback))
+    null !== dehydrated$69
+      ? (showFallback = createWorkInProgress(dehydrated$69, showFallback))
       : ((showFallback = createFiberFromFragment(
           showFallback,
           didSuspend,
@@ -5523,10 +5913,10 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
       ? (didSuspend = mountSuspenseOffscreenState(renderLanes))
       : ((JSCompiler_temp = didSuspend.cachePool),
         null !== JSCompiler_temp
-          ? ((dehydrated$63 = CacheContext._currentValue),
+          ? ((dehydrated$69 = CacheContext._currentValue),
             (JSCompiler_temp =
-              JSCompiler_temp.parent !== dehydrated$63
-                ? { parent: dehydrated$63, pool: dehydrated$63 }
+              JSCompiler_temp.parent !== dehydrated$69
+                ? { parent: dehydrated$69, pool: dehydrated$69 }
                 : JSCompiler_temp))
           : (JSCompiler_temp = getSuspendedCache()),
         (didSuspend = {
@@ -5534,6 +5924,29 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
           cachePool: JSCompiler_temp
         }));
     showFallback.memoizedState = didSuspend;
+    enableTransitionTracing &&
+      ((didSuspend = enableTransitionTracing ? transitionStack.current : null),
+      null !== didSuspend &&
+        ((JSCompiler_temp = enableTransitionTracing
+          ? markerInstanceStack.current
+          : null),
+        (dehydrated$69 = showFallback.updateQueue),
+        (primaryChildProps = current.updateQueue),
+        null === dehydrated$69
+          ? (showFallback.updateQueue = {
+              transitions: didSuspend,
+              markerInstances: JSCompiler_temp,
+              wakeables: null
+            })
+          : dehydrated$69 === primaryChildProps
+          ? (showFallback.updateQueue = {
+              transitions: didSuspend,
+              markerInstances: JSCompiler_temp,
+              wakeables:
+                null !== primaryChildProps ? primaryChildProps.wakeables : null
+            })
+          : ((dehydrated$69.transitions = didSuspend),
+            (dehydrated$69.markerInstances = JSCompiler_temp))));
     showFallback.childLanes = current.childLanes & ~renderLanes;
     workInProgress.memoizedState = SUSPENDED_MARKER;
     return nextProps;
@@ -5627,12 +6040,14 @@ function updateDehydratedSuspenseComponent(
       return (
         pushPrimaryTreeSuspenseHandler(workInProgress),
         (workInProgress.flags &= -257),
-        (nextProps = createCapturedValue(Error(formatProdErrorMessage(422)))),
+        (suspenseState = createCapturedValue(
+          Error(formatProdErrorMessage(422))
+        )),
         retrySuspenseComponentWithoutHydrating(
           current,
           workInProgress,
           renderLanes,
-          nextProps
+          suspenseState
         )
       );
     if (null !== workInProgress.memoizedState)
@@ -5678,62 +6093,69 @@ function updateDehydratedSuspenseComponent(
       null
     );
   if ("$!" === suspenseInstance.data) {
-    nextProps =
+    suspenseState =
       suspenseInstance.nextSibling && suspenseInstance.nextSibling.dataset;
-    if (nextProps) var digest = nextProps.dgst;
-    nextProps = digest;
-    suspenseState = Error(formatProdErrorMessage(419));
-    suspenseState.digest = nextProps;
-    nextProps = createCapturedValue(suspenseState, nextProps, void 0);
+    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,
-      nextProps
+      suspenseState
     );
   }
+  enableLazyContextPropagation &&
+    !didReceiveUpdate &&
+    propagateParentContextChanges(current, workInProgress, renderLanes, !1);
   digest = 0 !== (renderLanes & current.childLanes);
   if (didReceiveUpdate || digest) {
     nextProps = workInProgressRoot;
     if (null !== nextProps) {
-      switch (renderLanes & -renderLanes) {
-        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 = 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
@@ -5912,7 +6334,19 @@ function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
 function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
   null !== current && (workInProgress.dependencies = current.dependencies);
   workInProgressRootSkippedLanes |= workInProgress.lanes;
-  if (0 === (renderLanes & workInProgress.childLanes)) return null;
+  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) {
@@ -5928,6 +6362,14 @@ function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
   }
   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,
@@ -5936,6 +6378,9 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
   switch (workInProgress.tag) {
     case 3:
       pushHostRootContext(workInProgress);
+      enableTransitionTracing &&
+        push(transitionStack, workInProgressTransitions);
+      enableTransitionTracing && pushRootMarkerInstance(workInProgress);
       pushProvider(workInProgress, CacheContext, current.memoizedState.cache);
       resetHydrationState();
       break;
@@ -5979,8 +6424,18 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
       pushPrimaryTreeSuspenseHandler(workInProgress);
       break;
     case 19:
+      var didSuspendBefore = 0 !== (current.flags & 128);
       state = 0 !== (renderLanes & workInProgress.childLanes);
-      if (0 !== (current.flags & 128)) {
+      enableLazyContextPropagation &&
+        !state &&
+        (propagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes,
+          !1
+        ),
+        (state = 0 !== (renderLanes & workInProgress.childLanes)));
+      if (didSuspendBefore) {
         if (state)
           return updateSuspenseListComponent(
             current,
@@ -5989,11 +6444,11 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
           );
         workInProgress.flags |= 128;
       }
-      var renderState = workInProgress.memoizedState;
-      null !== renderState &&
-        ((renderState.rendering = null),
-        (renderState.tail = null),
-        (renderState.lastEffect = null));
+      didSuspendBefore = workInProgress.memoizedState;
+      null !== didSuspendBefore &&
+        ((didSuspendBefore.rendering = null),
+        (didSuspendBefore.tail = null),
+        (didSuspendBefore.lastEffect = null));
       push(suspenseStackCursor, suspenseStackCursor.current);
       if (state) break;
       else return null;
@@ -6005,6 +6460,11 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
       );
     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);
 }
@@ -6044,78 +6504,200 @@ function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
   }
 }
 function propagateContextChange(workInProgress, context, renderLanes) {
-  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;
+  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;
           }
-          fiber.lanes |= renderLanes;
-          dependency = fiber.alternate;
-          null !== dependency && (dependency.lanes |= renderLanes);
-          scheduleContextWorkOnParentPath(
-            fiber.return,
-            renderLanes,
-            workInProgress
-          );
-          list.lanes |= renderLanes;
-          break;
+          dependency = dependency.next;
         }
-        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;
+      } 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.sibling;
-        if (null !== fiber) {
-          fiber.return = nextFiber.return;
-          nextFiber = fiber;
-          break;
+      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;
+          }
+          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]));
         }
-        nextFiber = nextFiber.return;
       }
-    fiber = nextFiber;
+      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 &&
-    null !== workInProgress.firstContext &&
-    (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
-    (workInProgress.firstContext = null));
+    (enableLazyContextPropagation
+      ? (workInProgress.firstContext = null)
+      : null !== workInProgress.firstContext &&
+        (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
+        (workInProgress.firstContext = null)));
 }
 function readContext(context) {
   return readContextForConsumer(currentlyRenderingFiber, context);
@@ -6135,6 +6717,7 @@ function readContextForConsumer(consumer, context) {
       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;
 }
@@ -6183,17 +6766,32 @@ function releaseCache(cache) {
     });
 }
 var ReactCurrentBatchConfig$2 = ReactSharedInternals.ReactCurrentBatchConfig,
-  resumedCache = createCursor(null);
+  resumedCache = createCursor(null),
+  transitionStack = createCursor(null);
 function peekCacheFromPool() {
   var cacheResumedFromPreviousRender = resumedCache.current;
   return null !== cacheResumedFromPreviousRender
     ? cacheResumedFromPreviousRender
     : workInProgressRoot.pooledCache;
 }
-function pushTransition(offscreenWorkInProgress, prevCachePool) {
+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();
@@ -6440,14 +7038,14 @@ function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
         break;
       case "collapsed":
         lastTailNode = renderState.tail;
-        for (var lastTailNode$88 = null; null !== lastTailNode; )
-          null !== lastTailNode.alternate && (lastTailNode$88 = lastTailNode),
+        for (var lastTailNode$100 = null; null !== lastTailNode; )
+          null !== lastTailNode.alternate && (lastTailNode$100 = lastTailNode),
             (lastTailNode = lastTailNode.sibling);
-        null === lastTailNode$88
+        null === lastTailNode$100
           ? hasRenderedATailFallback || null === renderState.tail
             ? (renderState.tail = null)
             : (renderState.tail.sibling = null)
-          : (lastTailNode$88.sibling = null);
+          : (lastTailNode$100.sibling = null);
     }
 }
 function bubbleProperties(completedWork) {
@@ -6457,19 +7055,19 @@ function bubbleProperties(completedWork) {
     newChildLanes = 0,
     subtreeFlags = 0;
   if (didBailout)
-    for (var child$89 = completedWork.child; null !== child$89; )
-      (newChildLanes |= child$89.lanes | child$89.childLanes),
-        (subtreeFlags |= child$89.subtreeFlags & 14680064),
-        (subtreeFlags |= child$89.flags & 14680064),
-        (child$89.return = completedWork),
-        (child$89 = child$89.sibling);
+    for (var child$101 = completedWork.child; null !== child$101; )
+      (newChildLanes |= child$101.lanes | child$101.childLanes),
+        (subtreeFlags |= child$101.subtreeFlags & 14680064),
+        (subtreeFlags |= child$101.flags & 14680064),
+        (child$101.return = completedWork),
+        (child$101 = child$101.sibling);
   else
-    for (child$89 = completedWork.child; null !== child$89; )
-      (newChildLanes |= child$89.lanes | child$89.childLanes),
-        (subtreeFlags |= child$89.subtreeFlags),
-        (subtreeFlags |= child$89.flags),
-        (child$89.return = completedWork),
-        (child$89 = child$89.sibling);
+    for (child$101 = completedWork.child; null !== child$101; )
+      (newChildLanes |= child$101.lanes | child$101.childLanes),
+        (subtreeFlags |= child$101.subtreeFlags),
+        (subtreeFlags |= child$101.flags),
+        (child$101.return = completedWork),
+        (child$101 = child$101.sibling);
   completedWork.subtreeFlags |= subtreeFlags;
   completedWork.childLanes = newChildLanes;
   return didBailout;
@@ -6497,11 +7095,18 @@ function completeWork(current, workInProgress, renderLanes) {
       );
     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);
@@ -6520,6 +7125,9 @@ function completeWork(current, workInProgress, renderLanes) {
               (queueRecoverableErrors(hydrationErrors),
               (hydrationErrors = null)));
       bubbleProperties(workInProgress);
+      enableTransitionTracing &&
+        0 !== (workInProgress.subtreeFlags & 8192) &&
+        (workInProgress.flags |= 2048);
       return null;
     case 26:
       return (
@@ -6672,29 +7280,25 @@ function completeWork(current, workInProgress, renderLanes) {
           throw Error(formatProdErrorMessage(166));
         current = rootInstanceStackCursor.current;
         if (popHydrationState(workInProgress)) {
-          current = workInProgress.stateNode;
-          renderLanes = workInProgress.memoizedProps;
-          current[internalInstanceKey] = workInProgress;
-          if ((newProps = current.nodeValue !== renderLanes))
+          newProps = workInProgress.stateNode;
+          current = workInProgress.memoizedProps;
+          newProps[internalInstanceKey] = workInProgress;
+          if ((renderLanes = newProps.nodeValue !== current))
             if (((type = hydrationParentFiber), null !== type))
               switch (type.tag) {
                 case 3:
-                  checkForUnmatchedText(
-                    current.nodeValue,
-                    renderLanes,
-                    0 !== (type.mode & 1)
-                  );
+                  newProps = newProps.nodeValue;
+                  normalizeMarkupForTextOrAttribute(current);
+                  normalizeMarkupForTextOrAttribute(newProps);
                   break;
                 case 27:
                 case 5:
                   !0 !== type.memoizedProps.suppressHydrationWarning &&
-                    checkForUnmatchedText(
-                      current.nodeValue,
-                      renderLanes,
-                      0 !== (type.mode & 1)
-                    );
+                    ((newProps = newProps.nodeValue),
+                    normalizeMarkupForTextOrAttribute(current),
+                    normalizeMarkupForTextOrAttribute(newProps));
               }
-          newProps && markUpdate(workInProgress);
+          renderLanes && markUpdate(workInProgress);
         } else
           (current =
             getOwnerDocumentFromRootContainer(current).createTextNode(
@@ -6757,15 +7361,15 @@ function completeWork(current, workInProgress, renderLanes) {
           null !== newProps.alternate.memoizedState &&
           null !== newProps.alternate.memoizedState.cachePool &&
           (type = newProps.alternate.memoizedState.cachePool.pool);
-        var cache$99 = null;
+        var cache$111 = null;
         null !== newProps.memoizedState &&
           null !== newProps.memoizedState.cachePool &&
-          (cache$99 = newProps.memoizedState.cachePool.pool);
-        cache$99 !== type && (newProps.flags |= 2048);
+          (cache$111 = newProps.memoizedState.cachePool.pool);
+        cache$111 !== type && (newProps.flags |= 2048);
       }
       renderLanes !== current &&
-        renderLanes &&
-        (workInProgress.child.flags |= 8192);
+        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
+        renderLanes && (workInProgress.child.flags |= 8192));
       null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
       null !== workInProgress.updateQueue &&
         null != workInProgress.memoizedProps.suspenseCallback &&
@@ -6797,8 +7401,8 @@ function completeWork(current, workInProgress, renderLanes) {
       type = workInProgress.memoizedState;
       if (null === type) return bubbleProperties(workInProgress), null;
       newProps = 0 !== (workInProgress.flags & 128);
-      cache$99 = type.rendering;
-      if (null === cache$99)
+      cache$111 = type.rendering;
+      if (null === cache$111)
         if (newProps) cutOffTailIfNeeded(type, !1);
         else {
           if (
@@ -6806,11 +7410,11 @@ function completeWork(current, workInProgress, renderLanes) {
             (null !== current && 0 !== (current.flags & 128))
           )
             for (current = workInProgress.child; null !== current; ) {
-              cache$99 = findFirstSuspended(current);
-              if (null !== cache$99) {
+              cache$111 = findFirstSuspended(current);
+              if (null !== cache$111) {
                 workInProgress.flags |= 128;
                 cutOffTailIfNeeded(type, !1);
-                current = cache$99.updateQueue;
+                current = cache$111.updateQueue;
                 null !== current &&
                   ((workInProgress.updateQueue = current),
                   (workInProgress.flags |= 4));
@@ -6836,7 +7440,7 @@ function completeWork(current, workInProgress, renderLanes) {
         }
       else {
         if (!newProps)
-          if (((current = findFirstSuspended(cache$99)), null !== current)) {
+          if (((current = findFirstSuspended(cache$111)), null !== current)) {
             if (
               ((workInProgress.flags |= 128),
               (newProps = !0),
@@ -6847,7 +7451,7 @@ function completeWork(current, workInProgress, renderLanes) {
               cutOffTailIfNeeded(type, !0),
               null === type.tail &&
                 "hidden" === type.tailMode &&
-                !cache$99.alternate &&
+                !cache$111.alternate &&
                 !isHydrating)
             )
               return bubbleProperties(workInProgress), null;
@@ -6860,13 +7464,13 @@ function completeWork(current, workInProgress, renderLanes) {
               cutOffTailIfNeeded(type, !1),
               (workInProgress.lanes = 8388608));
         type.isBackwards
-          ? ((cache$99.sibling = workInProgress.child),
-            (workInProgress.child = cache$99))
+          ? ((cache$111.sibling = workInProgress.child),
+            (workInProgress.child = cache$111))
           : ((current = type.last),
             null !== current
-              ? (current.sibling = cache$99)
-              : (workInProgress.child = cache$99),
-            (type.last = cache$99));
+              ? (current.sibling = cache$111)
+              : (workInProgress.child = cache$111),
+            (type.last = cache$111));
       }
       if (null !== type.tail)
         return (
@@ -6905,15 +7509,18 @@ function completeWork(current, workInProgress, renderLanes) {
         popSuspenseHandler(workInProgress),
         popHiddenContext(),
         (newProps = null !== workInProgress.memoizedState),
-        null !== current
-          ? (null !== current.memoizedState) !== newProps &&
-            (workInProgress.flags |= 8192)
-          : newProps && (workInProgress.flags |= 8192),
+        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),
-            workInProgress.subtreeFlags & 6 && (workInProgress.flags |= 8192))
+            23 !== workInProgress.tag &&
+              workInProgress.subtreeFlags & 6 &&
+              (workInProgress.flags |= 8192))
           : bubbleProperties(workInProgress),
         null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
         (renderLanes = null),
@@ -6926,7 +7533,7 @@ function completeWork(current, workInProgress, renderLanes) {
           null !== workInProgress.memoizedState.cachePool &&
           (newProps = workInProgress.memoizedState.cachePool.pool),
         newProps !== renderLanes && (workInProgress.flags |= 2048),
-        null !== current && pop(resumedCache),
+        popTransition(workInProgress, current),
         null
       );
     case 24:
@@ -6940,7 +7547,14 @@ function completeWork(current, workInProgress, renderLanes) {
         null
       );
     case 25:
-      return null;
+      return (
+        enableTransitionTracing &&
+          (null !== workInProgress.stateNode &&
+            enableTransitionTracing &&
+            pop(markerInstanceStack),
+          bubbleProperties(workInProgress)),
+        null
+      );
   }
   throw Error(formatProdErrorMessage(156, workInProgress.tag));
 }
@@ -6958,6 +7572,10 @@ function unwindWork(current, workInProgress) {
     case 3:
       return (
         popProvider(CacheContext),
+        enableTransitionTracing &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        enableTransitionTracing && pop(transitionStack),
         popHostContainer(),
         pop(didPerformWorkStackCursor),
         pop(contextStackCursor),
@@ -6994,7 +7612,7 @@ function unwindWork(current, workInProgress) {
       return (
         popSuspenseHandler(workInProgress),
         popHiddenContext(),
-        null !== current && pop(resumedCache),
+        popTransition(workInProgress, current),
         (current = workInProgress.flags),
         current & 65536
           ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
@@ -7003,7 +7621,13 @@ function unwindWork(current, workInProgress) {
     case 24:
       return popProvider(CacheContext), null;
     case 25:
-      return null;
+      return (
+        enableTransitionTracing &&
+          null !== workInProgress.stateNode &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        null
+      );
     default:
       return null;
   }
@@ -7017,6 +7641,10 @@ function unwindInterruptedWork(current, interruptedWork) {
       break;
     case 3:
       popProvider(CacheContext);
+      enableTransitionTracing &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
+      enableTransitionTracing && pop(transitionStack);
       popHostContainer();
       pop(didPerformWorkStackCursor);
       pop(contextStackCursor);
@@ -7043,10 +7671,16 @@ function unwindInterruptedWork(current, interruptedWork) {
     case 23:
       popSuspenseHandler(interruptedWork);
       popHiddenContext();
-      null !== current && pop(resumedCache);
+      popTransition(interruptedWork, current);
       break;
     case 24:
       popProvider(CacheContext);
+      break;
+    case 25:
+      enableTransitionTracing &&
+        null !== interruptedWork.stateNode &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
   }
 }
 var ReactFbErrorUtils = require("ReactFbErrorUtils");
@@ -7135,8 +7769,8 @@ function safelyDetachRef(current, nearestMountedAncestor) {
     else if ("function" === typeof ref)
       try {
         ref(null);
-      } catch (error$113) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error$113);
+      } catch (error$127) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error$127);
       }
     else ref.current = null;
 }
@@ -7275,6 +7909,16 @@ function commitBeforeMutationEffects(root, firstChild) {
             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;
             case 11:
             case 15:
@@ -7426,11 +8070,11 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
               current,
               finishedRoot.__reactInternalSnapshotBeforeUpdate
             );
-          } catch (error$115) {
+          } catch (error$129) {
             captureCommitPhaseError(
               finishedWork,
               finishedWork.return,
-              error$115
+              error$129
             );
           }
         }
@@ -7508,26 +8152,210 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
       recursivelyTraverseLayoutEffects(finishedRoot, finishedWork);
   }
 }
-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 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 isHostParent(fiber) {
+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
+                    );
+                  })));
+        });
+  }
+}
+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 ||
@@ -7829,6 +8657,26 @@ function getRetryCache(finishedWork) {
       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 attachSuspenseRetryListeners(finishedWork, wakeables) {
   var retryCache = getRetryCache(finishedWork);
   wakeables.forEach(function (wakeable) {
@@ -7900,8 +8748,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         }
         try {
           commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
-        } catch (error$127) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$127);
+        } catch (error$142) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$142);
         }
       }
       break;
@@ -8079,11 +8927,11 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
               newProps
             );
             domElement[internalPropsKey] = newProps;
-          } catch (error$128) {
+          } catch (error$143) {
             captureCommitPhaseError(
               finishedWork,
               finishedWork.return,
-              error$128
+              error$143
             );
           }
       break;
@@ -8119,8 +8967,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         root = finishedWork.stateNode;
         try {
           setTextContent(root, "");
-        } catch (error$129) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$129);
+        } catch (error$144) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$144);
         }
       }
       if (
@@ -8137,8 +8985,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         try {
           updateProperties(flags, maybeNodes, hoistableRoot, current, root),
             (flags[internalPropsKey] = root);
-        } catch (error$132) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$132);
+        } catch (error$147) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$147);
         }
       break;
     case 6:
@@ -8151,8 +8999,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         flags = finishedWork.memoizedProps;
         try {
           current.nodeValue = flags;
-        } catch (error$133) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$133);
+        } catch (error$148) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$148);
         }
       }
       break;
@@ -8166,8 +9014,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
       if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
         try {
           retryIfBlockedOn(root.containerInfo);
-        } catch (error$134) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$134);
+        } catch (error$149) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$149);
         }
       break;
     case 4:
@@ -8197,8 +9045,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
               null !== wakeables && suspenseCallback(new Set(wakeables));
             }
           }
-        } catch (error$136) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$136);
+        } catch (error$151) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$151);
         }
         current = finishedWork.updateQueue;
         null !== current &&
@@ -8276,11 +9124,11 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
             if (null === current)
               try {
                 root.stateNode.nodeValue = domElement ? "" : root.memoizedProps;
-              } catch (error$117) {
+              } catch (error$132) {
                 captureCommitPhaseError(
                   finishedWork,
                   finishedWork.return,
-                  error$117
+                  error$132
                 );
               }
           } else if (
@@ -8355,21 +9203,21 @@ function commitReconciliationEffects(finishedWork) {
             insertOrAppendPlacementNode(finishedWork, before, parent$jscomp$0);
             break;
           case 5:
-            var parent$118 = JSCompiler_inline_result.stateNode;
+            var parent$133 = JSCompiler_inline_result.stateNode;
             JSCompiler_inline_result.flags & 32 &&
-              (setTextContent(parent$118, ""),
+              (setTextContent(parent$133, ""),
               (JSCompiler_inline_result.flags &= -33));
-            var before$119 = getHostSibling(finishedWork);
-            insertOrAppendPlacementNode(finishedWork, before$119, parent$118);
+            var before$134 = getHostSibling(finishedWork);
+            insertOrAppendPlacementNode(finishedWork, before$134, parent$133);
             break;
           case 3:
           case 4:
-            var parent$120 = JSCompiler_inline_result.stateNode.containerInfo,
-              before$121 = getHostSibling(finishedWork);
+            var parent$135 = JSCompiler_inline_result.stateNode.containerInfo,
+              before$136 = getHostSibling(finishedWork);
             insertOrAppendPlacementNodeIntoContainer(
               finishedWork,
-              before$121,
-              parent$120
+              before$136,
+              parent$135
             );
             break;
           default:
@@ -8543,7 +9391,7 @@ function commitHookPassiveMountEffects(finishedWork, hookFlags) {
     captureCommitPhaseError(finishedWork, finishedWork.return, error);
   }
 }
-function commitOffscreenPassiveMountEffects(current, finishedWork) {
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
   var previousCache = null;
   null !== current &&
     null !== current.memoizedState &&
@@ -8556,6 +9404,41 @@ function commitOffscreenPassiveMountEffects(current, finishedWork) {
   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;
@@ -8565,6 +9448,19 @@ function commitCachePassiveMountEffect(current, finishedWork) {
   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,
@@ -8607,21 +9503,78 @@ function commitPassiveMountOnFiber(
         committedLanes,
         committedTransitions
       );
-      flags & 2048 &&
-        ((finishedRoot = null),
+      if (flags & 2048) {
+        flags = null;
         null !== finishedWork.alternate &&
-          (finishedRoot = finishedWork.alternate.memoizedState.cache),
-        (finishedWork = finishedWork.memoizedState.cache),
-        finishedWork !== finishedRoot &&
-          (finishedWork.refCount++,
-          null != finishedRoot && releaseCache(finishedRoot)));
+          (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:
-      var instance = finishedWork.stateNode;
+      nextCache = finishedWork.stateNode;
       null !== finishedWork.memoizedState
-        ? instance._visibility & 4
+        ? nextCache._visibility & 4
           ? recursivelyTraversePassiveMountEffects(
               finishedRoot,
               finishedWork,
@@ -8630,21 +9583,21 @@ function commitPassiveMountOnFiber(
             )
           : finishedWork.mode & 1
           ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork)
-          : ((instance._visibility |= 4),
+          : ((nextCache._visibility |= 4),
             recursivelyTraversePassiveMountEffects(
               finishedRoot,
               finishedWork,
               committedLanes,
               committedTransitions
             ))
-        : instance._visibility & 4
+        : nextCache._visibility & 4
         ? recursivelyTraversePassiveMountEffects(
             finishedRoot,
             finishedWork,
             committedLanes,
             committedTransitions
           )
-        : ((instance._visibility |= 4),
+        : ((nextCache._visibility |= 4),
           recursivelyTraverseReconnectPassiveEffects(
             finishedRoot,
             finishedWork,
@@ -8655,7 +9608,8 @@ function commitPassiveMountOnFiber(
       flags & 2048 &&
         commitOffscreenPassiveMountEffects(
           finishedWork.alternate,
-          finishedWork
+          finishedWork,
+          nextCache
         );
       break;
     case 24:
@@ -8668,6 +9622,17 @@ function commitPassiveMountOnFiber(
       flags & 2048 &&
         commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
       break;
+    case 25:
+      if (enableTransitionTracing) {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
+        flags & 2048 && commitTracingMarkerPassiveMountEffect(finishedWork);
+        break;
+      }
     default:
       recursivelyTraversePassiveMountEffects(
         finishedRoot,
@@ -8706,11 +9671,25 @@ function recursivelyTraverseReconnectPassiveEffects(
         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 = finishedWork.stateNode;
+        var instance$161 = finishedWork.stateNode;
         null !== finishedWork.memoizedState
-          ? instance._visibility & 4
+          ? instance$161._visibility & 4
             ? recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork,
@@ -8723,7 +9702,7 @@ function recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork
               )
-            : ((instance._visibility |= 4),
+            : ((instance$161._visibility |= 4),
               recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork,
@@ -8731,7 +9710,7 @@ function recursivelyTraverseReconnectPassiveEffects(
                 committedTransitions,
                 includeWorkInProgressEffects
               ))
-          : ((instance._visibility |= 4),
+          : ((instance$161._visibility |= 4),
             recursivelyTraverseReconnectPassiveEffects(
               finishedRoot,
               finishedWork,
@@ -8743,7 +9722,8 @@ function recursivelyTraverseReconnectPassiveEffects(
           flags & 2048 &&
           commitOffscreenPassiveMountEffects(
             finishedWork.alternate,
-            finishedWork
+            finishedWork,
+            instance$161
           );
         break;
       case 24:
@@ -8758,6 +9738,20 @@ function recursivelyTraverseReconnectPassiveEffects(
           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,
@@ -8785,7 +9779,8 @@ function recursivelyTraverseAtomicPassiveEffects(
           flags & 2048 &&
             commitOffscreenPassiveMountEffects(
               finishedWork.alternate,
-              finishedWork
+              finishedWork,
+              finishedWork.stateNode
             );
           break;
         case 24:
@@ -8891,10 +9886,11 @@ function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
 }
 function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
   deletedSubtreeRoot,
-  nearestMountedAncestor
+  nearestMountedAncestor$jscomp$0
 ) {
   for (; null !== nextEffect; ) {
-    var fiber = nextEffect;
+    var fiber = nextEffect,
+      nearestMountedAncestor = nearestMountedAncestor$jscomp$0;
     switch (fiber.tag) {
       case 0:
       case 11:
@@ -8903,35 +9899,87 @@ function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
         break;
       case 23:
       case 22:
-        if (
-          null !== fiber.memoizedState &&
-          null !== fiber.memoizedState.cachePool
-        ) {
-          var cache = fiber.memoizedState.cachePool.pool;
-          null != cache && cache.refCount++;
+        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
+              )));
     }
-    cache = fiber.child;
-    if (null !== cache) (cache.return = fiber), (nextEffect = cache);
+    nearestMountedAncestor = fiber.child;
+    if (null !== nearestMountedAncestor)
+      (nearestMountedAncestor.return = fiber),
+        (nextEffect = nearestMountedAncestor);
     else
       a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
-        cache = nextEffect;
-        var sibling = cache.sibling,
-          returnFiber = cache.return;
-        detachFiberAfterEffects(cache);
-        if (cache === fiber) {
+        nearestMountedAncestor = nextEffect;
+        offscreenFiber = nearestMountedAncestor.sibling;
+        instance = nearestMountedAncestor.return;
+        detachFiberAfterEffects(nearestMountedAncestor);
+        if (nearestMountedAncestor === fiber) {
           nextEffect = null;
           break a;
         }
-        if (null !== sibling) {
-          sibling.return = returnFiber;
-          nextEffect = sibling;
+        if (null !== offscreenFiber) {
+          offscreenFiber.return = instance;
+          nextEffect = offscreenFiber;
           break a;
         }
-        nextEffect = returnFiber;
+        nextEffect = instance;
       }
   }
 }
@@ -9134,6 +10182,18 @@ function findAllNodes(hostRoot, selectors) {
   }
   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,
@@ -9157,7 +10217,70 @@ var ceil = Math.ceil,
   workInProgressRootRecoverableErrors = null,
   globalMostRecentFallbackTime = 0,
   workInProgressRootRenderTargetTime = Infinity,
-  workInProgressTransitions = null;
+  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;
 }
@@ -9182,7 +10305,11 @@ function requestEventTime() {
 }
 function requestUpdateLane(fiber) {
   if (0 === (fiber.mode & 1)) return 2;
-  if (0 !== (executionContext & 2) && 0 !== workInProgressRootRenderLanes)
+  if (
+    !deferRenderPhaseUpdateToNextBatch &&
+    0 !== (executionContext & 2) &&
+    0 !== workInProgressRootRenderLanes
+  )
     return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
   if (null !== ReactCurrentBatchConfig$2.transition)
     return (
@@ -9202,18 +10329,35 @@ function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
     (prepareFreshStack(root, 0),
     markRootSuspended(root, workInProgressRootRenderLanes));
   markRootUpdated(root, lane, eventTime);
-  if (0 === (executionContext & 2) || root !== workInProgressRoot)
-    root === workInProgressRoot &&
-      (0 === (executionContext & 2) &&
-        (workInProgressRootInterleavedUpdatedLanes |= lane),
+  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 (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());
+        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;
@@ -9282,7 +10426,7 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
   didTimeout =
     includesBlockingLane(root, lanes) ||
     0 !== (lanes & root.expiredLanes) ||
-    didTimeout
+    (!disableSchedulerTimeoutInWorkLoop && didTimeout)
       ? renderRootSync(root, lanes)
       : renderRootConcurrent(root, lanes);
   if (0 !== didTimeout) {
@@ -9319,16 +10463,16 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
         didTimeout = renderRootSync(root, lanes);
         if (2 === didTimeout) {
           errorRetryLanes = lanes;
-          var errorRetryLanes$148 = getLanesToRetrySynchronouslyOnError(
+          var errorRetryLanes$171 = getLanesToRetrySynchronouslyOnError(
             root,
             errorRetryLanes
           );
-          0 !== errorRetryLanes$148 &&
-            ((lanes = errorRetryLanes$148),
+          0 !== errorRetryLanes$171 &&
+            ((lanes = errorRetryLanes$171),
             (didTimeout = recoverFromConcurrentError(
               root,
               errorRetryLanes,
-              errorRetryLanes$148
+              errorRetryLanes$171
             )));
         }
         if (1 === didTimeout)
@@ -9382,11 +10526,11 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
           if ((lanes & 8388480) === lanes) break;
           didTimeout = root.eventTimes;
           for (originallyAttemptedLanes = -1; 0 < lanes; )
-            (errorRetryLanes$148 = 31 - clz32(lanes)),
-              (errorRetryLanes = 1 << errorRetryLanes$148),
-              (errorRetryLanes$148 = didTimeout[errorRetryLanes$148]),
-              errorRetryLanes$148 > originallyAttemptedLanes &&
-                (originallyAttemptedLanes = errorRetryLanes$148),
+            (errorRetryLanes$171 = 31 - clz32(lanes)),
+              (errorRetryLanes = 1 << errorRetryLanes$171),
+              (errorRetryLanes$171 = didTimeout[errorRetryLanes$171]),
+              errorRetryLanes$171 > originallyAttemptedLanes &&
+                (originallyAttemptedLanes = errorRetryLanes$171),
               (lanes &= ~errorRetryLanes);
           lanes = originallyAttemptedLanes;
           lanes = now() - lanes;
@@ -9702,7 +10846,8 @@ function renderRootSync(root, lanes) {
   var prevDispatcher = pushDispatcher(root.containerInfo),
     prevCacheDispatcher = pushCacheDispatcher();
   if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
-    (workInProgressTransitions = null), prepareFreshStack(root, lanes);
+    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
+      prepareFreshStack(root, lanes);
   a: do
     try {
       if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
@@ -9721,8 +10866,8 @@ function renderRootSync(root, lanes) {
       }
       workLoopSync();
       break;
-    } catch (thrownValue$151) {
-      handleThrow(root, thrownValue$151);
+    } catch (thrownValue$174) {
+      handleThrow(root, thrownValue$174);
     }
   while (1);
   resetContextDependencies();
@@ -9746,7 +10891,7 @@ function renderRootConcurrent(root, lanes) {
   var prevDispatcher = pushDispatcher(root.containerInfo),
     prevCacheDispatcher = pushCacheDispatcher();
   if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
-    (workInProgressTransitions = null),
+    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
       resetRenderTimer(),
       prepareFreshStack(root, lanes);
   a: do
@@ -9802,8 +10947,8 @@ function renderRootConcurrent(root, lanes) {
       }
       workLoopConcurrent();
       break;
-    } catch (thrownValue$153) {
-      handleThrow(root, thrownValue$153);
+    } catch (thrownValue$176) {
+      handleThrow(root, thrownValue$176);
     }
   while (1);
   resetContextDependencies();
@@ -9892,8 +11037,18 @@ function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
           "object" === typeof value &&
           "function" === typeof value.then
         ) {
-          var wakeable = value,
-            tag = unitOfWork.tag;
+          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)
@@ -9941,10 +11096,10 @@ function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
                     };
                     suspenseBoundary.updateQueue = newOffscreenQueue;
                   } else {
-                    var wakeables$52 = offscreenQueue.wakeables;
-                    null === wakeables$52
+                    var wakeables$57 = offscreenQueue.wakeables;
+                    null === wakeables$57
                       ? (offscreenQueue.wakeables = new Set([wakeable]))
-                      : wakeables$52.add(wakeable);
+                      : wakeables$57.add(wakeable);
                   }
                   break;
                 }
@@ -9993,7 +11148,7 @@ function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
               enqueueCapturedUpdate(root, update);
               break a;
             case 1:
-              tag = value;
+              currentSourceFiber = value;
               var ctor = root.type,
                 instance = root.stateNode;
               if (
@@ -10007,7 +11162,11 @@ function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
                 root.flags |= 65536;
                 update = thrownValue & -thrownValue;
                 root.lanes |= update;
-                errorInfo = createClassErrorUpdate(root, tag, update);
+                errorInfo = createClassErrorUpdate(
+                  root,
+                  currentSourceFiber,
+                  update
+                );
                 enqueueCapturedUpdate(root, errorInfo);
                 break a;
               }
@@ -10120,12 +11279,12 @@ function commitRootImpl(
     var prevExecutionContext = executionContext;
     executionContext |= 4;
     ReactCurrentOwner.current = null;
-    var shouldFireAfterActiveInstanceBlur$156 = commitBeforeMutationEffects(
+    var shouldFireAfterActiveInstanceBlur$179 = commitBeforeMutationEffects(
       root,
       finishedWork
     );
     commitMutationEffectsOnFiber(finishedWork, root);
-    shouldFireAfterActiveInstanceBlur$156 &&
+    shouldFireAfterActiveInstanceBlur$179 &&
       ((_enabled = !0),
       dispatchAfterDetachedBlur(selectionInformation.focusedElem),
       (_enabled = !1));
@@ -10177,6 +11336,23 @@ function commitRootImpl(
       : ((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) {
@@ -10187,51 +11363,64 @@ function releaseRootPooledCache(root, remainingLanes) {
 }
 function flushPassiveEffects() {
   if (null !== rootWithPendingPassiveEffects) {
-    var root$157 = rootWithPendingPassiveEffects,
+    var root$180 = rootWithPendingPassiveEffects,
       remainingLanes = pendingPassiveEffectsRemainingLanes;
     pendingPassiveEffectsRemainingLanes = 0;
-    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes),
-      priority = 32 > renderPriority ? 32 : renderPriority;
-    renderPriority = ReactCurrentBatchConfig$1.transition;
-    var previousPriority = currentUpdatePriority;
+    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    renderPriority = 32 > renderPriority ? 32 : renderPriority;
+    var prevTransition = ReactCurrentBatchConfig$1.transition,
+      previousPriority = currentUpdatePriority;
     try {
-      ReactCurrentBatchConfig$1.transition = null;
-      currentUpdatePriority = priority;
-      if (null === rootWithPendingPassiveEffects)
-        var JSCompiler_inline_result = !1;
-      else {
-        priority = 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, priority);
-        executionContext = prevExecutionContext;
-        flushSyncCallbacks();
-        if (
-          injectedHook &&
-          "function" === typeof injectedHook.onPostCommitFiberRoot
-        )
-          try {
-            injectedHook.onPostCommitFiberRoot(rendererID, root);
-          } catch (err) {}
-        JSCompiler_inline_result = !0;
-      }
-      return JSCompiler_inline_result;
+      return (
+        (ReactCurrentBatchConfig$1.transition = null),
+        (currentUpdatePriority = renderPriority),
+        flushPassiveEffectsImpl()
+      );
     } finally {
       (currentUpdatePriority = previousPriority),
-        (ReactCurrentBatchConfig$1.transition = renderPriority),
-        releaseRootPooledCache(root$157, remainingLanes);
+        (ReactCurrentBatchConfig$1.transition = prevTransition),
+        releaseRootPooledCache(root$180, remainingLanes);
     }
   }
   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;
+}
 function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
   sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
   sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
@@ -10245,7 +11434,13 @@ function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
   if (3 === sourceFiber.tag)
     captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
   else
-    for (; null !== nearestMountedAncestor; ) {
+    for (
+      nearestMountedAncestor = skipUnmountedBoundaries
+        ? nearestMountedAncestor
+        : sourceFiber.return;
+      null !== nearestMountedAncestor;
+
+    ) {
       if (3 === nearestMountedAncestor.tag) {
         captureCommitPhaseErrorOnRoot(
           nearestMountedAncestor,
@@ -10364,7 +11559,7 @@ beginWork = function (current, workInProgress, renderLanes) {
       didReceiveUpdate = !0;
     else {
       if (
-        0 === (current.lanes & renderLanes) &&
+        !checkScheduledUpdateOrContext(current, renderLanes) &&
         0 === (workInProgress.flags & 128)
       )
         return (
@@ -10502,6 +11697,9 @@ beginWork = function (current, workInProgress, renderLanes) {
         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 &&
@@ -10803,7 +12001,7 @@ beginWork = function (current, workInProgress, renderLanes) {
         prevState = workInProgress.memoizedProps;
         root = context.value;
         pushProvider(workInProgress, Component, root);
-        if (null !== prevState)
+        if (!enableLazyContextPropagation && null !== prevState)
           if (objectIs(prevState.value, root)) {
             if (
               prevState.children === context.children &&
@@ -10897,6 +12095,8 @@ beginWork = function (current, workInProgress, renderLanes) {
       );
     case 22:
       return updateOffscreenComponent(current, workInProgress, renderLanes);
+    case 23:
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
     case 24:
       return (
         prepareToReadContext(workInProgress, renderLanes),
@@ -10945,6 +12145,37 @@ beginWork = function (current, workInProgress, 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));
 };
@@ -11115,13 +12346,14 @@ function createFiberFromTypeAndProps(
       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 (
-          (key = createFiber(21, pendingProps, key, mode)),
-          (key.type = type),
-          (key.elementType = type),
-          (key.lanes = lanes),
-          key
+          (pendingProps = createFiber(21, pendingProps, key, mode)),
+          (pendingProps.type = type),
+          (pendingProps.elementType = type),
+          (pendingProps.lanes = lanes),
+          pendingProps
         );
       case REACT_CACHE_TYPE:
         return (
@@ -11130,6 +12362,27 @@ function createFiberFromTypeAndProps(
           (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) {
@@ -11154,11 +12407,11 @@ function createFiberFromTypeAndProps(
           formatProdErrorMessage(130, null == type ? type : typeof type, "")
         );
     }
-  key = createFiber(fiberTag, pendingProps, key, mode);
-  key.elementType = type;
-  key.type = owner;
-  key.lanes = lanes;
-  return key;
+  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);
@@ -11177,29 +12430,36 @@ function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
     _transitions: null,
     _current: null,
     detach: function () {
-      var fiber = primaryChildInstance._current;
-      if (null === fiber) throw Error(formatProdErrorMessage(456));
-      if (0 === (primaryChildInstance._pendingVisibility & 2)) {
-        var root = enqueueConcurrentRenderForLane(fiber, 2);
-        null !== root &&
-          ((primaryChildInstance._pendingVisibility |= 2),
-          scheduleUpdateOnFiber(root, fiber, 2, -1));
-      }
+      return detachOffscreenInstance(primaryChildInstance);
     },
     attach: function () {
-      var fiber = primaryChildInstance._current;
-      if (null === fiber) throw Error(formatProdErrorMessage(456));
-      if (0 !== (primaryChildInstance._pendingVisibility & 2)) {
-        var root = enqueueConcurrentRenderForLane(fiber, 2);
-        null !== root &&
-          ((primaryChildInstance._pendingVisibility &= -3),
-          scheduleUpdateOnFiber(root, fiber, 2, -1));
-      }
+      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;
@@ -11256,6 +12516,15 @@ function FiberRootNode(
   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,
@@ -11266,7 +12535,8 @@ function createFiberRoot(
   isStrictMode,
   concurrentUpdatesByDefaultOverride,
   identifierPrefix,
-  onRecoverableError
+  onRecoverableError,
+  transitionCallbacks
 ) {
   containerInfo = new FiberRootNode(
     containerInfo,
@@ -11276,6 +12546,8 @@ function createFiberRoot(
     onRecoverableError
   );
   containerInfo.hydrationCallbacks = hydrationCallbacks;
+  enableTransitionTracing &&
+    (containerInfo.transitionCallbacks = transitionCallbacks);
   1 === tag
     ? ((tag = 1),
       !0 === isStrictMode && (tag |= 24),
@@ -11354,7 +12626,8 @@ function createHydrationContainer(
   isStrictMode,
   concurrentUpdatesByDefaultOverride,
   identifierPrefix,
-  onRecoverableError
+  onRecoverableError,
+  transitionCallbacks
 ) {
   initialChildren = createFiberRoot(
     containerInfo,
@@ -11365,7 +12638,8 @@ function createHydrationContainer(
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   );
   initialChildren.context = getContextForSubtree(null);
   containerInfo = initialChildren.current;
@@ -11472,7 +12746,11 @@ ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function (target) {
 function isValidContainer(node) {
   return !(
     !node ||
-    (1 !== node.nodeType && 9 !== node.nodeType && 11 !== node.nodeType)
+    (1 !== node.nodeType &&
+      9 !== node.nodeType &&
+      11 !== node.nodeType &&
+      (8 !== node.nodeType ||
+        " react-mount-point-unstable " !== node.nodeValue))
   );
 }
 function isValidContainerLegacy(node) {
@@ -11497,11 +12775,11 @@ function legacyCreateRootFromDOMContainer(
     if ("function" === typeof callback) {
       var originalCallback = callback;
       callback = function () {
-        var instance = getPublicRootInstance(root$160);
+        var instance = getPublicRootInstance(root$183);
         originalCallback.call(instance);
       };
     }
-    var root$160 = createHydrationContainer(
+    var root$183 = createHydrationContainer(
       initialChildren,
       callback,
       container,
@@ -11510,25 +12788,26 @@ function legacyCreateRootFromDOMContainer(
       !1,
       !1,
       "",
-      noopOnRecoverableError
+      noopOnRecoverableError,
+      null
     );
-    container._reactRootContainer = root$160;
-    container[internalContainerInstanceKey] = root$160.current;
+    container._reactRootContainer = root$183;
+    container[internalContainerInstanceKey] = root$183.current;
     listenToAllSupportedEvents(
       8 === container.nodeType ? container.parentNode : container
     );
     flushSync$1();
-    return root$160;
+    return root$183;
   }
   clearContainer(container);
   if ("function" === typeof callback) {
-    var originalCallback$161 = callback;
+    var originalCallback$184 = callback;
     callback = function () {
-      var instance = getPublicRootInstance(root$162);
-      originalCallback$161.call(instance);
+      var instance = getPublicRootInstance(root$185);
+      originalCallback$184.call(instance);
     };
   }
-  var root$162 = createFiberRoot(
+  var root$185 = createFiberRoot(
     container,
     0,
     !1,
@@ -11537,17 +12816,18 @@ function legacyCreateRootFromDOMContainer(
     !1,
     !1,
     "",
-    noopOnRecoverableError
+    noopOnRecoverableError,
+    null
   );
-  container._reactRootContainer = root$162;
-  container[internalContainerInstanceKey] = root$162.current;
+  container._reactRootContainer = root$185;
+  container[internalContainerInstanceKey] = root$185.current;
   listenToAllSupportedEvents(
     8 === container.nodeType ? container.parentNode : container
   );
   flushSync$1(function () {
-    updateContainer(initialChildren, root$162, parentComponent, callback);
+    updateContainer(initialChildren, root$185, parentComponent, callback);
   });
-  return root$162;
+  return root$185;
 }
 function legacyRenderSubtreeIntoContainer(
   parentComponent,
@@ -11650,12 +12930,12 @@ function batchedUpdates(fn, a, b) {
 _attemptSynchronousHydration = function (fiber) {
   switch (fiber.tag) {
     case 3:
-      var root$159 = fiber.stateNode;
-      if (root$159.current.memoizedState.isDehydrated) {
-        var lanes = getHighestPriorityLanes(root$159.pendingLanes);
+      var root$182 = fiber.stateNode;
+      if (root$182.current.memoizedState.isDehydrated) {
+        var lanes = getHighestPriorityLanes(root$182.pendingLanes);
         0 !== lanes &&
-          (markRootEntangled(root$159, lanes | 2),
-          ensureRootIsScheduled(root$159, now()),
+          (markRootEntangled(root$182, lanes | 2),
+          ensureRootIsScheduled(root$182, now()),
           0 === (executionContext & 6) &&
             (resetRenderTimer(), flushSyncCallbacks()));
       }
@@ -11671,6 +12951,16 @@ _attemptSynchronousHydration = function (fiber) {
         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);
@@ -11735,17 +13025,17 @@ Internals.Events = [
   restoreStateIfNeeded,
   batchedUpdates$1
 ];
-var devToolsConfig$jscomp$inline_1552 = {
+var devToolsConfig$jscomp$inline_1631 = {
   findFiberByHostInstance: getClosestInstanceFromNode,
   bundleType: 0,
-  version: "18.3.0-www-classic-dd1bbdc2",
+  version: "18.3.0-www-classic-5ea6b0b1",
   rendererPackageName: "react-dom"
 };
-var internals$jscomp$inline_2106 = {
-  bundleType: devToolsConfig$jscomp$inline_1552.bundleType,
-  version: devToolsConfig$jscomp$inline_1552.version,
-  rendererPackageName: devToolsConfig$jscomp$inline_1552.rendererPackageName,
-  rendererConfig: devToolsConfig$jscomp$inline_1552.rendererConfig,
+var internals$jscomp$inline_2194 = {
+  bundleType: devToolsConfig$jscomp$inline_1631.bundleType,
+  version: devToolsConfig$jscomp$inline_1631.version,
+  rendererPackageName: devToolsConfig$jscomp$inline_1631.rendererPackageName,
+  rendererConfig: devToolsConfig$jscomp$inline_1631.rendererConfig,
   overrideHookState: null,
   overrideHookStateDeletePath: null,
   overrideHookStateRenamePath: null,
@@ -11761,26 +13051,26 @@ var internals$jscomp$inline_2106 = {
     return null === fiber ? null : fiber.stateNode;
   },
   findFiberByHostInstance:
-    devToolsConfig$jscomp$inline_1552.findFiberByHostInstance ||
+    devToolsConfig$jscomp$inline_1631.findFiberByHostInstance ||
     emptyFindFiberByHostInstance,
   findHostInstancesForRefresh: null,
   scheduleRefresh: null,
   scheduleRoot: null,
   setRefreshHandler: null,
   getCurrentFiber: null,
-  reconcilerVersion: "18.3.0-www-classic-dd1bbdc2"
+  reconcilerVersion: "18.3.0-www-classic-5ea6b0b1"
 };
 if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
-  var hook$jscomp$inline_2107 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+  var hook$jscomp$inline_2195 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
   if (
-    !hook$jscomp$inline_2107.isDisabled &&
-    hook$jscomp$inline_2107.supportsFiber
+    !hook$jscomp$inline_2195.isDisabled &&
+    hook$jscomp$inline_2195.supportsFiber
   )
     try {
-      (rendererID = hook$jscomp$inline_2107.inject(
-        internals$jscomp$inline_2106
+      (rendererID = hook$jscomp$inline_2195.inject(
+        internals$jscomp$inline_2194
       )),
-        (injectedHook = hook$jscomp$inline_2107);
+        (injectedHook = hook$jscomp$inline_2195);
     } catch (err) {}
 }
 var Dispatcher = Internals.Dispatcher,
@@ -11899,12 +13189,12 @@ function preinit(href, options) {
       switch (as) {
         case "style":
           as = getResourcesFromRoot(resourceRoot).hoistableStyles;
-          var key$164 = getStyleKey(href),
+          var key$187 = getStyleKey(href),
             precedence = options.precedence || "default",
-            resource = as.get(key$164);
+            resource = as.get(key$187);
           if (resource) break;
           resource = resourceRoot.querySelector(
-            getStylesheetSelectorFromKey(key$164)
+            getStylesheetSelectorFromKey(key$187)
           );
           resource ||
             ((href = {
@@ -11913,7 +13203,7 @@ function preinit(href, options) {
               "data-precedence": precedence,
               crossOrigin: options.crossOrigin
             }),
-            (options = preloadPropsMap.get(key$164)) &&
+            (options = preloadPropsMap.get(key$187)) &&
               adoptPreloadPropsForStylesheet(href, options),
             (resource = (
               resourceRoot.ownerDocument || resourceRoot
@@ -11922,15 +13212,15 @@ function preinit(href, options) {
             setInitialProperties(resource, "link", href),
             insertStylesheet(resource, precedence, resourceRoot));
           resource = { type: "stylesheet", instance: resource, count: 1 };
-          as.set(key$164, resource);
+          as.set(key$187, resource);
           break;
         case "script":
           (as = getResourcesFromRoot(resourceRoot).hoistableScripts),
-            (key$164 = getScriptKey(href)),
-            (precedence = as.get(key$164)),
+            (key$187 = getScriptKey(href)),
+            (precedence = as.get(key$187)),
             precedence ||
               ((precedence = resourceRoot.querySelector(
-                "script[async]" + key$164
+                "script[async]" + key$187
               )),
               precedence ||
                 ((href = {
@@ -11939,7 +13229,7 @@ function preinit(href, options) {
                   crossOrigin: options.crossOrigin,
                   integrity: options.integrity
                 }),
-                (options = preloadPropsMap.get(key$164)) &&
+                (options = preloadPropsMap.get(key$187)) &&
                   adoptPreloadPropsForScript(href, options),
                 (options = resourceRoot.ownerDocument || resourceRoot),
                 (precedence = options.createElement("script")),
@@ -11947,13 +13237,13 @@ function preinit(href, options) {
                 setInitialProperties(precedence, "link", href),
                 options.head.appendChild(precedence)),
               (precedence = { type: "script", instance: precedence, count: 1 }),
-              as.set(key$164, precedence));
+              as.set(key$187, precedence));
       }
     else if ("style" === as || "script" === as)
       if ((resourceRoot = getDocumentForPreloads())) {
-        key$164 = escapeSelectorAttributeValueInsideDoubleQuotes(href);
-        precedence = key$164 =
-          'link[rel="preload"][as="' + as + '"][href="' + key$164 + '"]';
+        key$187 = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+        precedence = key$187 =
+          'link[rel="preload"][as="' + as + '"][href="' + key$187 + '"]';
         switch (as) {
           case "style":
             precedence = getStyleKey(href);
@@ -11970,7 +13260,7 @@ function preinit(href, options) {
             integrity: options.integrity
           }),
           preloadPropsMap.set(precedence, href),
-          null === resourceRoot.querySelector(key$164) &&
+          null === resourceRoot.querySelector(key$187) &&
             ((options = resourceRoot.createElement("link")),
             setInitialProperties(options, "link", href),
             markNodeAsHoistable(options),
@@ -12002,14 +13292,14 @@ function getResource(type, currentProps, pendingProps) {
         "string" === typeof pendingProps.href &&
         "string" === typeof pendingProps.precedence
       ) {
-        var key$171 = getStyleKey(pendingProps.href),
-          styles$172 = getResourcesFromRoot(currentProps).hoistableStyles;
-        type = styles$172.get(key$171);
+        var key$194 = getStyleKey(pendingProps.href),
+          styles$195 = getResourcesFromRoot(currentProps).hoistableStyles;
+        type = styles$195.get(key$194);
         type ||
           ((currentProps = currentProps.ownerDocument || currentProps),
           (type = { type: "stylesheet", instance: null, count: 0 }),
-          styles$172.set(key$171, type),
-          preloadPropsMap.has(key$171) ||
+          styles$195.set(key$194, type),
+          preloadPropsMap.has(key$194) ||
             ((pendingProps = {
               rel: "preload",
               as: "style",
@@ -12020,16 +13310,16 @@ function getResource(type, currentProps, pendingProps) {
               hrefLang: pendingProps.hrefLang,
               referrerPolicy: pendingProps.referrerPolicy
             }),
-            preloadPropsMap.set(key$171, pendingProps),
-            currentProps.querySelector(getStylesheetSelectorFromKey(key$171)) ||
+            preloadPropsMap.set(key$194, pendingProps),
+            currentProps.querySelector(getStylesheetSelectorFromKey(key$194)) ||
               null !==
                 currentProps.querySelector(
-                  'link[rel="preload"][as="style"][' + key$171 + "]"
+                  'link[rel="preload"][as="style"][' + key$194 + "]"
                 ) ||
-              ((key$171 = currentProps.createElement("link")),
-              setInitialProperties(key$171, "link", pendingProps),
-              markNodeAsHoistable(key$171),
-              currentProps.head.appendChild(key$171))));
+              ((key$194 = currentProps.createElement("link")),
+              setInitialProperties(key$194, "link", pendingProps),
+              markNodeAsHoistable(key$194),
+              currentProps.head.appendChild(key$194))));
         return type;
       }
       return null;
@@ -12079,14 +13369,14 @@ function acquireResource(hoistableRoot, resource, props) {
         return (resource.instance = key);
       case "stylesheet":
         styleProps = getStyleKey(props.href);
-        var instance$178 = hoistableRoot.querySelector(
+        var instance$201 = hoistableRoot.querySelector(
           getStylesheetSelectorFromKey(styleProps)
         );
-        if (instance$178)
+        if (instance$201)
           return (
-            (resource.instance = instance$178),
-            markNodeAsHoistable(instance$178),
-            instance$178
+            (resource.instance = instance$201),
+            markNodeAsHoistable(instance$201),
+            instance$201
           );
         key = assign({}, props, {
           "data-precedence": props.precedence,
@@ -12094,11 +13384,11 @@ function acquireResource(hoistableRoot, resource, props) {
         });
         (styleProps = preloadPropsMap.get(styleProps)) &&
           adoptPreloadPropsForStylesheet(key, styleProps);
-        instance$178 = (
+        instance$201 = (
           hoistableRoot.ownerDocument || hoistableRoot
         ).createElement("link");
-        markNodeAsHoistable(instance$178);
-        var linkInstance = instance$178;
+        markNodeAsHoistable(instance$201);
+        var linkInstance = instance$201;
         linkInstance._p = new Promise(function (resolve, reject) {
           linkInstance.onload = resolve;
           linkInstance.onerror = reject;
@@ -12110,14 +13400,14 @@ function acquireResource(hoistableRoot, resource, props) {
             return (linkInstance._p.s = "e");
           }
         );
-        setInitialProperties(instance$178, "link", key);
-        insertStylesheet(instance$178, props.precedence, hoistableRoot);
-        return (resource.instance = instance$178);
+        setInitialProperties(instance$201, "link", key);
+        insertStylesheet(instance$201, props.precedence, hoistableRoot);
+        return (resource.instance = instance$201);
       case "script":
-        instance$178 = getScriptKey(props.src);
+        instance$201 = getScriptKey(props.src);
         if (
           (styleProps = hoistableRoot.querySelector(
-            "script[async]" + instance$178
+            "script[async]" + instance$201
           ))
         )
           return (
@@ -12126,7 +13416,7 @@ function acquireResource(hoistableRoot, resource, props) {
             styleProps
           );
         key = props;
-        if ((styleProps = preloadPropsMap.get(instance$178)))
+        if ((styleProps = preloadPropsMap.get(instance$201)))
           (key = assign({}, props)),
             adoptPreloadPropsForScript(key, styleProps);
         hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
@@ -12247,7 +13537,11 @@ function shouldSetTextContent(type, props) {
 }
 var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0,
   cancelTimeout = "function" === typeof clearTimeout ? clearTimeout : void 0,
-  localPromise = "function" === typeof Promise ? Promise : void 0;
+  localPromise = "function" === typeof Promise ? Promise : void 0,
+  localRequestAnimationFrame =
+    "function" === typeof requestAnimationFrame
+      ? requestAnimationFrame
+      : scheduleTimeout;
 function getInstanceFromScope(scopeInstance) {
   scopeInstance = scopeInstance[internalInstanceKey] || null;
   return scopeInstance;
@@ -12458,6 +13752,13 @@ function setupIntersectionObserver(targets, callback, options) {
     }
   };
 }
+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;
@@ -13135,19 +14436,19 @@ function getTargetInstForChangeEvent(domEventName, targetInst) {
 }
 var isInputEventSupported = !1;
 if (canUseDOM) {
-  var JSCompiler_inline_result$jscomp$296;
+  var JSCompiler_inline_result$jscomp$318;
   if (canUseDOM) {
-    var isSupported$jscomp$inline_1627 = "oninput" in document;
-    if (!isSupported$jscomp$inline_1627) {
-      var element$jscomp$inline_1628 = document.createElement("div");
-      element$jscomp$inline_1628.setAttribute("oninput", "return;");
-      isSupported$jscomp$inline_1627 =
-        "function" === typeof element$jscomp$inline_1628.oninput;
-    }
-    JSCompiler_inline_result$jscomp$296 = isSupported$jscomp$inline_1627;
-  } else JSCompiler_inline_result$jscomp$296 = !1;
+    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;
+    }
+    JSCompiler_inline_result$jscomp$318 = isSupported$jscomp$inline_1706;
+  } else JSCompiler_inline_result$jscomp$318 = !1;
   isInputEventSupported =
-    JSCompiler_inline_result$jscomp$296 &&
+    JSCompiler_inline_result$jscomp$318 &&
     (!document.documentMode || 9 < document.documentMode);
 }
 function stopWatchingForValueChange() {
@@ -13285,20 +14586,20 @@ function registerSimpleEvent(domEventName, reactName) {
   registerTwoPhaseEvent(reactName, [domEventName]);
 }
 for (
-  var i$jscomp$inline_1640 = 0;
-  i$jscomp$inline_1640 < simpleEventPluginEvents.length;
-  i$jscomp$inline_1640++
+  var i$jscomp$inline_1719 = 0;
+  i$jscomp$inline_1719 < simpleEventPluginEvents.length;
+  i$jscomp$inline_1719++
 ) {
-  var eventName$jscomp$inline_1641 =
-      simpleEventPluginEvents[i$jscomp$inline_1640],
-    domEventName$jscomp$inline_1642 =
-      eventName$jscomp$inline_1641.toLowerCase(),
-    capitalizedEvent$jscomp$inline_1643 =
-      eventName$jscomp$inline_1641[0].toUpperCase() +
-      eventName$jscomp$inline_1641.slice(1);
+  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);
   registerSimpleEvent(
-    domEventName$jscomp$inline_1642,
-    "on" + capitalizedEvent$jscomp$inline_1643
+    domEventName$jscomp$inline_1721,
+    "on" + capitalizedEvent$jscomp$inline_1722
   );
 }
 registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
@@ -13456,10 +14757,11 @@ function addTrappedEventListener(
       "touchmove" !== domEventName &&
       "wheel" !== domEventName) ||
     (isPassiveListener = !0);
-  targetContainer = isDeferredListenerForLegacyFBSupport
-    ? targetContainer.ownerDocument
-    : targetContainer;
-  if (isDeferredListenerForLegacyFBSupport) {
+  targetContainer =
+    enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport
+      ? targetContainer.ownerDocument
+      : targetContainer;
+  if (enableLegacyFBSupport && isDeferredListenerForLegacyFBSupport) {
     var originalListener = eventSystemFlags;
     eventSystemFlags = function () {
       unsubscribeListener.remove();
@@ -13504,6 +14806,7 @@ function dispatchEventForPluginEventSystem(
   var ancestorInst = targetInst$jscomp$0;
   if (0 === (eventSystemFlags & 1) && 0 === (eventSystemFlags & 2)) {
     if (
+      enableLegacyFBSupport &&
       "click" === domEventName &&
       0 === (eventSystemFlags & 20) &&
       nativeEvent !== currentReplayingEvent
@@ -13830,10 +15133,18 @@ function dispatchEventForPluginEventSystem(
             var handleEventFunc = handleEventsForInputEventPolyfill;
           }
         else
-          (SyntheticEventCtor = reactName.nodeName) &&
-            "input" === SyntheticEventCtor.toLowerCase() &&
-            ("checkbox" === reactName.type || "radio" === reactName.type) &&
-            (getTargetInstFunc = getTargetInstForClickEvent);
+          (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))
@@ -13851,7 +15162,8 @@ function dispatchEventForPluginEventSystem(
           (handleEventFunc = reactName._wrapperState) &&
           handleEventFunc.controlled &&
           "number" === reactName.type &&
-          setDefaultValue(reactName, "number", reactName.value);
+          (disableInputAttributeSyncing ||
+            setDefaultValue(reactName, "number", reactName.value));
       }
       handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
       switch (domEventName) {
@@ -14115,6 +15427,7 @@ function accumulateEventHandleNonManagedNodeListeners(
   return listeners;
 }
 var _attemptSynchronousHydration,
+  attemptDiscreteHydration,
   attemptContinuousHydration,
   attemptHydrationAtCurrentPriority,
   getCurrentUpdatePriority,
@@ -14131,6 +15444,48 @@ var _attemptSynchronousHydration,
     "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":
@@ -14167,13 +15522,13 @@ function accumulateOrCreateContinuousQueuedReplayableEvent(
     existingQueuedEvent.nativeEvent !== nativeEvent
   )
     return (
-      (existingQueuedEvent = {
-        blockedOn: blockedOn,
-        domEventName: domEventName,
-        eventSystemFlags: eventSystemFlags,
-        nativeEvent: nativeEvent,
-        targetContainers: [targetContainer]
-      }),
+      (existingQueuedEvent = createQueuedReplayableEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      )),
       null !== blockedOn &&
         ((blockedOn = getInstanceFromNode(blockedOn)),
         null !== blockedOn && attemptContinuousHydration(blockedOn)),
@@ -14299,22 +15654,29 @@ function attemptReplayContinuousQueuedEvent(queuedEvent) {
     0 < targetContainers.length;
 
   ) {
-    var nextBlockedOn = findInstanceBlockingEvent(
-      queuedEvent.domEventName,
-      queuedEvent.eventSystemFlags,
-      targetContainers[0],
-      queuedEvent.nativeEvent
-    );
-    if (null === nextBlockedOn) {
-      nextBlockedOn = queuedEvent.nativeEvent;
-      var nativeEventClone = new nextBlockedOn.constructor(
-        nextBlockedOn.type,
-        nextBlockedOn
+    var targetContainer = targetContainers[0],
+      nextBlockedOn = findInstanceBlockingEvent(
+        queuedEvent.domEventName,
+        queuedEvent.eventSystemFlags,
+        targetContainer,
+        queuedEvent.nativeEvent
       );
-      currentReplayingEvent = nativeEventClone;
-      nextBlockedOn.target.dispatchEvent(nativeEventClone);
-      currentReplayingEvent = null;
-    } else
+    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 &&
@@ -14331,6 +15693,45 @@ function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
 }
 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(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);
@@ -14447,67 +15848,129 @@ function dispatchEvent(
   targetContainer,
   nativeEvent
 ) {
-  if (_enabled) {
-    var blockedOn = findInstanceBlockingEvent(
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
-    if (null === blockedOn)
-      dispatchEventForPluginEventSystem(
-        domEventName,
-        eventSystemFlags,
-        nativeEvent,
-        return_targetInst,
-        targetContainer
-      ),
-        clearIfContinuousEvent(domEventName, nativeEvent);
-    else if (
-      queueIfContinuousEvent(
-        blockedOn,
+  if (_enabled)
+    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+      var blockedOn = findInstanceBlockingEvent(
         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(
+      );
+      if (null === blockedOn)
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          clearIfContinuousEvent(domEventName, nativeEvent);
+      else if (
+        queueIfContinuousEvent(
+          blockedOn,
           domEventName,
           eventSystemFlags,
           targetContainer,
           nativeEvent
-        );
-        null === fiber &&
-          dispatchEventForPluginEventSystem(
+        )
+      )
+        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,
-            nativeEvent,
-            return_targetInst,
-            targetContainer
+            targetContainer,
+            nativeEvent
           );
-        if (fiber === blockedOn) break;
-        blockedOn = fiber;
-      }
-      null !== blockedOn && nativeEvent.stopPropagation();
+          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
-      dispatchEventForPluginEventSystem(
-        domEventName,
-        eventSystemFlags,
-        nativeEvent,
-        null,
-        targetContainer
-      );
-  }
+      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(
@@ -14661,7 +16124,8 @@ exports.createRoot = function (container, options) {
   var isStrictMode = !1,
     concurrentUpdatesByDefaultOverride = !1,
     identifierPrefix = "",
-    onRecoverableError = defaultOnRecoverableError;
+    onRecoverableError = defaultOnRecoverableError,
+    transitionCallbacks = null;
   null !== options &&
     void 0 !== options &&
     (!0 === options.unstable_strictMode && (isStrictMode = !0),
@@ -14670,7 +16134,9 @@ exports.createRoot = function (container, options) {
     void 0 !== options.identifierPrefix &&
       (identifierPrefix = options.identifierPrefix),
     void 0 !== options.onRecoverableError &&
-      (onRecoverableError = options.onRecoverableError));
+      (onRecoverableError = options.onRecoverableError),
+    void 0 !== options.unstable_transitionCallbacks &&
+      (transitionCallbacks = options.unstable_transitionCallbacks));
   options = createFiberRoot(
     container,
     1,
@@ -14680,7 +16146,8 @@ exports.createRoot = function (container, options) {
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   );
   container[internalContainerInstanceKey] = options.current;
   Dispatcher$1.current = ReactDOMClientDispatcher;
@@ -14848,7 +16315,8 @@ exports.hydrateRoot = function (container, initialChildren, options) {
     isStrictMode = !1,
     concurrentUpdatesByDefaultOverride = !1,
     identifierPrefix = "",
-    onRecoverableError = defaultOnRecoverableError;
+    onRecoverableError = defaultOnRecoverableError,
+    transitionCallbacks = null;
   null !== options &&
     void 0 !== options &&
     (!0 === options.unstable_strictMode && (isStrictMode = !0),
@@ -14857,7 +16325,9 @@ exports.hydrateRoot = function (container, initialChildren, options) {
     void 0 !== options.identifierPrefix &&
       (identifierPrefix = options.identifierPrefix),
     void 0 !== options.onRecoverableError &&
-      (onRecoverableError = options.onRecoverableError));
+      (onRecoverableError = options.onRecoverableError),
+    void 0 !== options.unstable_transitionCallbacks &&
+      (transitionCallbacks = options.unstable_transitionCallbacks));
   initialChildren = createHydrationContainer(
     initialChildren,
     null,
@@ -14867,7 +16337,8 @@ exports.hydrateRoot = function (container, initialChildren, options) {
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   );
   container[internalContainerInstanceKey] = initialChildren.current;
   Dispatcher$1.current = ReactDOMClientDispatcher;
@@ -15017,4 +16488,4 @@ exports.unstable_renderSubtreeIntoContainer = function (
   );
 };
 exports.unstable_runWithPriority = runWithPriority;
-exports.version = "18.3.0-www-classic-dd1bbdc2";
+exports.version = "18.3.0-www-classic-5ea6b0b1";
diff --git a/compiled/facebook-www/ReactDOMTesting-prod.modern.js b/compiled/facebook-www/ReactDOMTesting-prod.modern.js
index 4c391d2e9f754..78406f9d02175 100644
--- a/compiled/facebook-www/ReactDOMTesting-prod.modern.js
+++ b/compiled/facebook-www/ReactDOMTesting-prod.modern.js
@@ -37,7 +37,32 @@ function formatProdErrorMessage(code) {
     " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."
   );
 }
-var randomKey = Math.random().toString(36).slice(2),
+var dynamicFeatureFlags = require("ReactFeatureFlags"),
+  disableInputAttributeSyncing =
+    dynamicFeatureFlags.disableInputAttributeSyncing,
+  enableTrustedTypesIntegration =
+    dynamicFeatureFlags.enableTrustedTypesIntegration,
+  enableFilterEmptyStringAttributesDOM =
+    dynamicFeatureFlags.enableFilterEmptyStringAttributesDOM,
+  enableLegacyFBSupport = dynamicFeatureFlags.enableLegacyFBSupport,
+  deferRenderPhaseUpdateToNextBatch =
+    dynamicFeatureFlags.deferRenderPhaseUpdateToNextBatch,
+  enableDebugTracing = dynamicFeatureFlags.enableDebugTracing,
+  skipUnmountedBoundaries = dynamicFeatureFlags.skipUnmountedBoundaries,
+  enableUseRefAccessWarning = dynamicFeatureFlags.enableUseRefAccessWarning,
+  disableNativeComponentFrames =
+    dynamicFeatureFlags.disableNativeComponentFrames,
+  disableSchedulerTimeoutInWorkLoop =
+    dynamicFeatureFlags.disableSchedulerTimeoutInWorkLoop,
+  enableLazyContextPropagation =
+    dynamicFeatureFlags.enableLazyContextPropagation,
+  enableUnifiedSyncLane = dynamicFeatureFlags.enableUnifiedSyncLane,
+  enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay =
+    dynamicFeatureFlags.enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay,
+  enableTransitionTracing = dynamicFeatureFlags.enableTransitionTracing,
+  enableCustomElementPropertySupport =
+    dynamicFeatureFlags.enableCustomElementPropertySupport,
+  randomKey = Math.random().toString(36).slice(2),
   internalInstanceKey = "__reactFiber$" + randomKey,
   internalPropsKey = "__reactProps$" + randomKey,
   internalContainerInstanceKey = "__reactContainer$" + randomKey,
@@ -293,8 +318,15 @@ function shouldRemoveAttribute(
     )
   )
     return !0;
-  if (isCustomComponentTag) return !1;
-  if (null !== propertyInfo)
+  if (isCustomComponentTag)
+    return enableCustomElementPropertySupport && !1 === value ? !0 : !1;
+  if (null !== propertyInfo) {
+    if (
+      enableFilterEmptyStringAttributesDOM &&
+      propertyInfo.removeEmptyString &&
+      "" === value
+    )
+      return !0;
     switch (propertyInfo.type) {
       case 3:
         return !value;
@@ -305,6 +337,7 @@ function shouldRemoveAttribute(
       case 6:
         return isNaN(value) || 1 > value;
     }
+  }
   return !1;
 }
 function PropertyInfoRecord(
@@ -325,12 +358,16 @@ function PropertyInfoRecord(
   this.sanitizeURL = sanitizeURL;
   this.removeEmptyString = removeEmptyString;
 }
-var properties = {};
-"children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style"
-  .split(" ")
-  .forEach(function (name) {
-    properties[name] = new PropertyInfoRecord(name, 0, !1, name, null, !1, !1);
-  });
+var properties = {},
+  reservedProps =
+    "children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style".split(
+      " "
+    );
+enableCustomElementPropertySupport &&
+  reservedProps.push("innerText", "textContent");
+reservedProps.forEach(function (name) {
+  properties[name] = new PropertyInfoRecord(name, 0, !1, name, null, !1, !1);
+});
 [
   ["acceptCharset", "accept-charset"],
   ["className", "class"],
@@ -491,20 +528,56 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
         !(2 < name.length) ||
         ("o" !== name[0] && "O" !== name[0]) ||
         ("n" !== name[1] && "N" !== name[1])
-  )
+  ) {
     if (
+      enableCustomElementPropertySupport &&
+      isCustomComponentTag &&
+      "o" === name[0] &&
+      "n" === name[1]
+    ) {
+      var eventName = name.replace(/Capture$/, ""),
+        useCapture = name !== eventName;
+      eventName = eventName.slice(2);
+      var prevProps = getFiberCurrentPropsFromNode(node);
+      prevProps = null != prevProps ? prevProps[name] : null;
+      "function" === typeof prevProps &&
+        node.removeEventListener(eventName, prevProps, useCapture);
+      if ("function" === typeof value) {
+        "function" !== typeof prevProps &&
+          null !== prevProps &&
+          (name in node
+            ? (node[name] = null)
+            : node.hasAttribute(name) && node.removeAttribute(name));
+        node.addEventListener(eventName, value, useCapture);
+        return;
+      }
+    }
+    if (
+      enableCustomElementPropertySupport &&
+      isCustomComponentTag &&
+      name in node
+    )
+      node[name] = value;
+    else if (
       (shouldRemoveAttribute(
         name,
         value,
         JSCompiler_inline_result,
         isCustomComponentTag
       ) && (value = null),
+      enableCustomElementPropertySupport &&
+        isCustomComponentTag &&
+        !0 === value &&
+        (value = ""),
       isCustomComponentTag || null === JSCompiler_inline_result)
     )
       isAttributeNameSafe(name) &&
         (null === value
           ? node.removeAttribute(name)
-          : node.setAttribute(name, "" + value));
+          : node.setAttribute(
+              name,
+              enableTrustedTypesIntegration ? value : "" + value
+            ));
     else if (JSCompiler_inline_result.mustUseProperty)
       node[JSCompiler_inline_result.propertyName] =
         null === value
@@ -519,10 +592,10 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
     )
       node.removeAttribute(name);
     else {
-      var type$2 = JSCompiler_inline_result.type;
-      if (3 === type$2 || (4 === type$2 && !0 === value)) value = "";
+      eventName = JSCompiler_inline_result.type;
+      if (3 === eventName || (4 === eventName && !0 === value)) value = "";
       else if (
-        ((value = "" + value),
+        ((value = enableTrustedTypesIntegration ? value : "" + value),
         JSCompiler_inline_result.sanitizeURL &&
           isJavaScriptProtocol.test(value.toString()))
       )
@@ -531,6 +604,7 @@ function setValueForProperty(node, name, value, isCustomComponentTag) {
         ? node.setAttributeNS(isCustomComponentTag, name, value)
         : node.setAttribute(name, value);
     }
+  }
 }
 var ReactSharedInternals =
     React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
@@ -547,15 +621,16 @@ var ReactSharedInternals =
   REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
   REACT_MEMO_TYPE = Symbol.for("react.memo"),
   REACT_LAZY_TYPE = Symbol.for("react.lazy"),
-  REACT_SCOPE_TYPE = Symbol.for("react.scope");
-Symbol.for("react.debug_trace_mode");
-var REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"),
+  REACT_SCOPE_TYPE = Symbol.for("react.scope"),
+  REACT_DEBUG_TRACING_MODE_TYPE = Symbol.for("react.debug_trace_mode"),
+  REACT_OFFSCREEN_TYPE = Symbol.for("react.offscreen"),
   REACT_LEGACY_HIDDEN_TYPE = Symbol.for("react.legacy_hidden"),
-  REACT_CACHE_TYPE = Symbol.for("react.cache");
-Symbol.for("react.tracing_marker");
-var REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for(
+  REACT_CACHE_TYPE = Symbol.for("react.cache"),
+  REACT_TRACING_MARKER_TYPE = Symbol.for("react.tracing_marker"),
+  REACT_SERVER_CONTEXT_DEFAULT_VALUE_NOT_LOADED = Symbol.for(
     "react.default_value"
   ),
+  REACT_MEMO_CACHE_SENTINEL = Symbol.for("react.memo_cache_sentinel"),
   MAYBE_ITERATOR_SYMBOL = Symbol.iterator;
 function getIteratorFn(maybeIterable) {
   if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
@@ -578,7 +653,7 @@ function describeBuiltInComponentFrame(name) {
 }
 var reentry = !1;
 function describeNativeComponentFrame(fn, construct) {
-  if (!fn || reentry) return "";
+  if (disableNativeComponentFrames || !fn || reentry) return "";
   reentry = !0;
   var previousPrepareStackTrace = Error.prepareStackTrace;
   Error.prepareStackTrace = void 0;
@@ -696,6 +771,8 @@ function getComponentNameFromType(type) {
       return "SuspenseList";
     case REACT_CACHE_TYPE:
       return "Cache";
+    case REACT_TRACING_MARKER_TYPE:
+      if (enableTransitionTracing) return "TracingMarker";
   }
   if ("object" === typeof type)
     switch (type.$$typeof) {
@@ -862,7 +939,10 @@ function updateWrapper$1(element, props) {
     element.removeAttribute("value");
     return;
   }
-  props.hasOwnProperty("value")
+  disableInputAttributeSyncing
+    ? props.hasOwnProperty("defaultValue") &&
+      setDefaultValue(element, props.type, getToStringValue(props.defaultValue))
+    : props.hasOwnProperty("value")
     ? setDefaultValue(element, props.type, value)
     : props.hasOwnProperty("defaultValue") &&
       setDefaultValue(
@@ -870,28 +950,44 @@ function updateWrapper$1(element, props) {
         props.type,
         getToStringValue(props.defaultValue)
       );
-  null == props.checked &&
-    null != props.defaultChecked &&
-    (element.defaultChecked = !!props.defaultChecked);
+  disableInputAttributeSyncing
+    ? null == props.defaultChecked
+      ? element.removeAttribute("checked")
+      : (element.defaultChecked = !!props.defaultChecked)
+    : null == props.checked &&
+      null != props.defaultChecked &&
+      (element.defaultChecked = !!props.defaultChecked);
 }
 function postMountWrapper$3(element, props, isHydrating) {
   if (props.hasOwnProperty("value") || props.hasOwnProperty("defaultValue")) {
     var type = props.type;
     if (
-      !(
-        ("submit" !== type && "reset" !== type) ||
-        (void 0 !== props.value && null !== props.value)
-      )
+      (type = "submit" === type || "reset" === type) &&
+      (void 0 === props.value || null === props.value)
     )
       return;
-    props = "" + element._wrapperState.initialValue;
-    isHydrating || props === element.value || (element.value = props);
-    element.defaultValue = props;
-  }
-  isHydrating = element.name;
-  "" !== isHydrating && (element.name = "");
-  element.defaultChecked = !!element._wrapperState.initialChecked;
-  "" !== isHydrating && (element.name = isHydrating);
+    var initialValue = "" + element._wrapperState.initialValue;
+    if (!isHydrating)
+      if (disableInputAttributeSyncing) {
+        var value = getToStringValue(props.value);
+        null == value ||
+          (!type && value === element.value) ||
+          (element.value = "" + value);
+      } else initialValue !== element.value && (element.value = initialValue);
+    disableInputAttributeSyncing
+      ? ((type = getToStringValue(props.defaultValue)),
+        null != type && (element.defaultValue = "" + type))
+      : (element.defaultValue = initialValue);
+  }
+  type = element.name;
+  "" !== type && (element.name = "");
+  disableInputAttributeSyncing
+    ? (isHydrating || updateChecked(element, props),
+      props.hasOwnProperty("defaultChecked") &&
+        ((element.defaultChecked = !element.defaultChecked),
+        (element.defaultChecked = !!props.defaultChecked)))
+    : (element.defaultChecked = !!element._wrapperState.initialChecked);
+  "" !== type && (element.name = type);
 }
 function setDefaultValue(node, type, value) {
   if ("number" !== type || getActiveElement(node.ownerDocument) !== node)
@@ -1465,8 +1561,10 @@ function clz32Fallback(x) {
 var nextTransitionLane = 128,
   nextRetryLane = 8388608;
 function getHighestPriorityLanes(lanes) {
-  var pendingSyncLanes = lanes & 42;
-  if (0 !== pendingSyncLanes) return pendingSyncLanes;
+  if (enableUnifiedSyncLane) {
+    var pendingSyncLanes = lanes & 42;
+    if (0 !== pendingSyncLanes) return pendingSyncLanes;
+  }
   switch (lanes & -lanes) {
     case 1:
       return 1;
@@ -1686,6 +1784,30 @@ function markRootEntangled(root, entangledLanes) {
     rootEntangledLanes &= ~lane;
   }
 }
+function getTransitionsForLanes(root, lanes) {
+  if (!enableTransitionTracing) return null;
+  for (var transitionsForLanes = []; 0 < lanes; ) {
+    var index$16 = 31 - clz32(lanes),
+      lane = 1 << index$16;
+    index$16 = root.transitionLanes[index$16];
+    null !== index$16 &&
+      index$16.forEach(function (transition) {
+        transitionsForLanes.push(transition);
+      });
+    lanes &= ~lane;
+  }
+  return 0 === transitionsForLanes.length ? null : transitionsForLanes;
+}
+function clearTransitionsForLanes(root, lanes) {
+  if (enableTransitionTracing)
+    for (; 0 < lanes; ) {
+      var index$17 = 31 - clz32(lanes),
+        lane = 1 << index$17;
+      null !== root.transitionLanes[index$17] &&
+        (root.transitionLanes[index$17] = null);
+      lanes &= ~lane;
+    }
+}
 var currentUpdatePriority = 0;
 function runWithPriority(priority, fn) {
   var previousPriority = currentUpdatePriority;
@@ -1706,6 +1828,7 @@ function lanesToEventPriority(lanes) {
     : 2;
 }
 var _attemptSynchronousHydration,
+  attemptDiscreteHydration$1,
   attemptContinuousHydration$1,
   attemptHydrationAtCurrentPriority$1,
   getCurrentUpdatePriority,
@@ -1722,6 +1845,48 @@ var _attemptSynchronousHydration,
     "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":
@@ -1758,13 +1923,13 @@ function accumulateOrCreateContinuousQueuedReplayableEvent(
     existingQueuedEvent.nativeEvent !== nativeEvent
   )
     return (
-      (existingQueuedEvent = {
-        blockedOn: blockedOn,
-        domEventName: domEventName,
-        eventSystemFlags: eventSystemFlags,
-        nativeEvent: nativeEvent,
-        targetContainers: [targetContainer]
-      }),
+      (existingQueuedEvent = createQueuedReplayableEvent(
+        blockedOn,
+        domEventName,
+        eventSystemFlags,
+        targetContainer,
+        nativeEvent
+      )),
       null !== blockedOn &&
         ((blockedOn = getInstanceFromNode$1(blockedOn)),
         null !== blockedOn && attemptContinuousHydration$1(blockedOn)),
@@ -1890,22 +2055,29 @@ function attemptReplayContinuousQueuedEvent(queuedEvent) {
     0 < targetContainers.length;
 
   ) {
-    var nextBlockedOn = findInstanceBlockingEvent(
-      queuedEvent.domEventName,
-      queuedEvent.eventSystemFlags,
-      targetContainers[0],
-      queuedEvent.nativeEvent
-    );
-    if (null === nextBlockedOn) {
-      nextBlockedOn = queuedEvent.nativeEvent;
-      var nativeEventClone = new nextBlockedOn.constructor(
-        nextBlockedOn.type,
-        nextBlockedOn
+    var targetContainer = targetContainers[0],
+      nextBlockedOn = findInstanceBlockingEvent(
+        queuedEvent.domEventName,
+        queuedEvent.eventSystemFlags,
+        targetContainer,
+        queuedEvent.nativeEvent
       );
-      currentReplayingEvent = nativeEventClone;
-      nextBlockedOn.target.dispatchEvent(nativeEventClone);
-      currentReplayingEvent = null;
-    } else
+    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 &&
@@ -1922,6 +2094,45 @@ function attemptReplayContinuousQueuedEventInMap(queuedEvent, key, map) {
 }
 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);
@@ -1976,6 +2187,28 @@ function retryIfBlockedOn(unblocked) {
 }
 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,
@@ -2016,67 +2249,129 @@ function dispatchEvent(
   targetContainer,
   nativeEvent
 ) {
-  if (_enabled) {
-    var blockedOn = findInstanceBlockingEvent(
-      domEventName,
-      eventSystemFlags,
-      targetContainer,
-      nativeEvent
-    );
-    if (null === blockedOn)
-      dispatchEventForPluginEventSystem(
-        domEventName,
-        eventSystemFlags,
-        nativeEvent,
-        return_targetInst,
-        targetContainer
-      ),
-        clearIfContinuousEvent(domEventName, nativeEvent);
-    else if (
-      queueIfContinuousEvent(
-        blockedOn,
+  if (_enabled)
+    if (enableCapturePhaseSelectiveHydrationWithoutDiscreteEventReplay) {
+      var blockedOn = findInstanceBlockingEvent(
         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(
+      );
+      if (null === blockedOn)
+        dispatchEventForPluginEventSystem(
+          domEventName,
+          eventSystemFlags,
+          nativeEvent,
+          return_targetInst,
+          targetContainer
+        ),
+          clearIfContinuousEvent(domEventName, nativeEvent);
+      else if (
+        queueIfContinuousEvent(
+          blockedOn,
           domEventName,
           eventSystemFlags,
           targetContainer,
           nativeEvent
-        );
-        null === fiber &&
-          dispatchEventForPluginEventSystem(
+        )
+      )
+        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,
-            nativeEvent,
-            return_targetInst,
-            targetContainer
+            targetContainer,
+            nativeEvent
           );
-        if (fiber === blockedOn) break;
-        blockedOn = fiber;
-      }
-      null !== blockedOn && nativeEvent.stopPropagation();
+          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
-      dispatchEventForPluginEventSystem(
-        domEventName,
-        eventSystemFlags,
-        nativeEvent,
-        null,
-        targetContainer
-      );
-  }
+      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(
@@ -2202,6 +2497,35 @@ function getEventPriority(domEventName) {
       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;
@@ -2666,19 +2990,19 @@ function getTargetInstForChangeEvent(domEventName, targetInst) {
 }
 var isInputEventSupported = !1;
 if (canUseDOM) {
-  var JSCompiler_inline_result$jscomp$220;
+  var JSCompiler_inline_result$jscomp$243;
   if (canUseDOM) {
-    var isSupported$jscomp$inline_366 = "oninput" in document;
-    if (!isSupported$jscomp$inline_366) {
-      var element$jscomp$inline_367 = document.createElement("div");
-      element$jscomp$inline_367.setAttribute("oninput", "return;");
-      isSupported$jscomp$inline_366 =
-        "function" === typeof element$jscomp$inline_367.oninput;
+    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$220 = isSupported$jscomp$inline_366;
-  } else JSCompiler_inline_result$jscomp$220 = !1;
+    JSCompiler_inline_result$jscomp$243 = isSupported$jscomp$inline_403;
+  } else JSCompiler_inline_result$jscomp$243 = !1;
   isInputEventSupported =
-    JSCompiler_inline_result$jscomp$220 &&
+    JSCompiler_inline_result$jscomp$243 &&
     (!document.documentMode || 9 < document.documentMode);
 }
 function stopWatchingForValueChange() {
@@ -3013,19 +3337,19 @@ function registerSimpleEvent(domEventName, reactName) {
   registerTwoPhaseEvent(reactName, [domEventName]);
 }
 for (
-  var i$jscomp$inline_407 = 0;
-  i$jscomp$inline_407 < simpleEventPluginEvents.length;
-  i$jscomp$inline_407++
+  var i$jscomp$inline_444 = 0;
+  i$jscomp$inline_444 < simpleEventPluginEvents.length;
+  i$jscomp$inline_444++
 ) {
-  var eventName$jscomp$inline_408 =
-      simpleEventPluginEvents[i$jscomp$inline_407],
-    domEventName$jscomp$inline_409 = eventName$jscomp$inline_408.toLowerCase(),
-    capitalizedEvent$jscomp$inline_410 =
-      eventName$jscomp$inline_408[0].toUpperCase() +
-      eventName$jscomp$inline_408.slice(1);
+  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_409,
-    "on" + capitalizedEvent$jscomp$inline_410
+    domEventName$jscomp$inline_446,
+    "on" + capitalizedEvent$jscomp$inline_447
   );
 }
 registerSimpleEvent(ANIMATION_END, "onAnimationEnd");
@@ -3169,42 +3493,58 @@ function addTrappedEventListener(
   targetContainer,
   domEventName,
   eventSystemFlags,
-  isCapturePhaseListener
+  isCapturePhaseListener,
+  isDeferredListenerForLegacyFBSupport
 ) {
-  switch (getEventPriority(domEventName)) {
-    case 2:
-      var listenerWrapper = dispatchDiscreteEvent;
-      break;
-    case 8:
-      listenerWrapper = dispatchContinuousEvent;
-      break;
-    default:
-      listenerWrapper = dispatchEvent;
-  }
-  eventSystemFlags = listenerWrapper.bind(
-    null,
+  eventSystemFlags = createEventListenerWrapperWithPriority(
+    targetContainer,
     domEventName,
-    eventSystemFlags,
-    targetContainer
+    eventSystemFlags
   );
-  listenerWrapper = void 0;
+  var isPassiveListener = void 0;
   !passiveBrowserEventsSupported ||
     ("touchstart" !== domEventName &&
       "touchmove" !== domEventName &&
       "wheel" !== domEventName) ||
-    (listenerWrapper = !0);
-  isCapturePhaseListener
-    ? void 0 !== listenerWrapper
-      ? targetContainer.addEventListener(domEventName, eventSystemFlags, {
-          capture: !0,
-          passive: listenerWrapper
-        })
-      : targetContainer.addEventListener(domEventName, eventSystemFlags, !0)
-    : void 0 !== listenerWrapper
-    ? targetContainer.addEventListener(domEventName, eventSystemFlags, {
-        passive: listenerWrapper
-      })
-    : targetContainer.addEventListener(domEventName, eventSystemFlags, !1);
+    (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++
+      )
+        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,
@@ -3214,52 +3554,60 @@ function dispatchEventForPluginEventSystem(
   targetContainer
 ) {
   var ancestorInst = targetInst$jscomp$0;
-  if (
-    0 === (eventSystemFlags & 1) &&
-    0 === (eventSystemFlags & 2) &&
-    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 (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 (
-            5 === grandTag ||
-            6 === grandTag ||
-            26 === grandTag ||
-            27 === grandTag
-          ) {
-            targetInst$jscomp$0 = ancestorInst = nodeTag;
-            continue a;
+            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;
           }
-          container = container.parentNode;
         }
+        targetInst$jscomp$0 = targetInst$jscomp$0.return;
       }
-      targetInst$jscomp$0 = targetInst$jscomp$0.return;
-    }
+  }
   batchedUpdates$1(function () {
     var targetInst = ancestorInst,
       nativeEventTarget = getEventTarget(nativeEvent),
@@ -3535,10 +3883,18 @@ function dispatchEventForPluginEventSystem(
             var handleEventFunc = handleEventsForInputEventPolyfill;
           }
         else
-          (SyntheticEventCtor = reactName.nodeName) &&
-            "input" === SyntheticEventCtor.toLowerCase() &&
-            ("checkbox" === reactName.type || "radio" === reactName.type) &&
-            (getTargetInstFunc = getTargetInstForClickEvent);
+          (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))
@@ -3556,7 +3912,8 @@ function dispatchEventForPluginEventSystem(
           (handleEventFunc = reactName._wrapperState) &&
           handleEventFunc.controlled &&
           "number" === reactName.type &&
-          setDefaultValue(reactName, "number", reactName.value);
+          (disableInputAttributeSyncing ||
+            setDefaultValue(reactName, "number", reactName.value));
       }
       handleEventFunc = targetInst ? getNodeFromInstance(targetInst) : window;
       switch (domEventName) {
@@ -3826,14 +4183,6 @@ function normalizeMarkupForTextOrAttribute(markup) {
     .replace(NORMALIZE_NEWLINES_REGEX, "\n")
     .replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, "");
 }
-function checkForUnmatchedText(serverText, clientText, isConcurrentMode) {
-  clientText = normalizeMarkupForTextOrAttribute(clientText);
-  if (
-    normalizeMarkupForTextOrAttribute(serverText) !== clientText &&
-    isConcurrentMode
-  )
-    throw Error(formatProdErrorMessage(425));
-}
 function getOwnerDocumentFromRootContainer(rootContainerElement) {
   return 9 === rootContainerElement.nodeType
     ? rootContainerElement
@@ -4188,12 +4537,12 @@ function preinit$1(href, options) {
       switch (as) {
         case "style":
           as = getResourcesFromRoot(resourceRoot).hoistableStyles;
-          var key$31 = getStyleKey(href),
+          var key$34 = getStyleKey(href),
             precedence = options.precedence || "default",
-            resource = as.get(key$31);
+            resource = as.get(key$34);
           if (resource) break;
           resource = resourceRoot.querySelector(
-            getStylesheetSelectorFromKey(key$31)
+            getStylesheetSelectorFromKey(key$34)
           );
           resource ||
             ((href = {
@@ -4202,7 +4551,7 @@ function preinit$1(href, options) {
               "data-precedence": precedence,
               crossOrigin: options.crossOrigin
             }),
-            (options = preloadPropsMap.get(key$31)) &&
+            (options = preloadPropsMap.get(key$34)) &&
               adoptPreloadPropsForStylesheet(href, options),
             (resource = (
               resourceRoot.ownerDocument || resourceRoot
@@ -4211,15 +4560,15 @@ function preinit$1(href, options) {
             setInitialProperties(resource, "link", href),
             insertStylesheet(resource, precedence, resourceRoot));
           resource = { type: "stylesheet", instance: resource, count: 1 };
-          as.set(key$31, resource);
+          as.set(key$34, resource);
           break;
         case "script":
           (as = getResourcesFromRoot(resourceRoot).hoistableScripts),
-            (key$31 = getScriptKey(href)),
-            (precedence = as.get(key$31)),
+            (key$34 = getScriptKey(href)),
+            (precedence = as.get(key$34)),
             precedence ||
               ((precedence = resourceRoot.querySelector(
-                "script[async]" + key$31
+                "script[async]" + key$34
               )),
               precedence ||
                 ((href = {
@@ -4228,7 +4577,7 @@ function preinit$1(href, options) {
                   crossOrigin: options.crossOrigin,
                   integrity: options.integrity
                 }),
-                (options = preloadPropsMap.get(key$31)) &&
+                (options = preloadPropsMap.get(key$34)) &&
                   adoptPreloadPropsForScript(href, options),
                 (options = resourceRoot.ownerDocument || resourceRoot),
                 (precedence = options.createElement("script")),
@@ -4236,13 +4585,13 @@ function preinit$1(href, options) {
                 setInitialProperties(precedence, "link", href),
                 options.head.appendChild(precedence)),
               (precedence = { type: "script", instance: precedence, count: 1 }),
-              as.set(key$31, precedence));
+              as.set(key$34, precedence));
       }
     else if ("style" === as || "script" === as)
       if ((resourceRoot = getDocumentForPreloads())) {
-        key$31 = escapeSelectorAttributeValueInsideDoubleQuotes(href);
-        precedence = key$31 =
-          'link[rel="preload"][as="' + as + '"][href="' + key$31 + '"]';
+        key$34 = escapeSelectorAttributeValueInsideDoubleQuotes(href);
+        precedence = key$34 =
+          'link[rel="preload"][as="' + as + '"][href="' + key$34 + '"]';
         switch (as) {
           case "style":
             precedence = getStyleKey(href);
@@ -4259,7 +4608,7 @@ function preinit$1(href, options) {
             integrity: options.integrity
           }),
           preloadPropsMap.set(precedence, href),
-          null === resourceRoot.querySelector(key$31) &&
+          null === resourceRoot.querySelector(key$34) &&
             ((options = resourceRoot.createElement("link")),
             setInitialProperties(options, "link", href),
             markNodeAsHoistable(options),
@@ -4291,14 +4640,14 @@ function getResource(type, currentProps, pendingProps) {
         "string" === typeof pendingProps.href &&
         "string" === typeof pendingProps.precedence
       ) {
-        var key$38 = getStyleKey(pendingProps.href),
-          styles$39 = getResourcesFromRoot(currentProps).hoistableStyles;
-        type = styles$39.get(key$38);
+        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$39.set(key$38, type),
-          preloadPropsMap.has(key$38) ||
+          styles$42.set(key$41, type),
+          preloadPropsMap.has(key$41) ||
             ((pendingProps = {
               rel: "preload",
               as: "style",
@@ -4309,16 +4658,16 @@ function getResource(type, currentProps, pendingProps) {
               hrefLang: pendingProps.hrefLang,
               referrerPolicy: pendingProps.referrerPolicy
             }),
-            preloadPropsMap.set(key$38, pendingProps),
-            currentProps.querySelector(getStylesheetSelectorFromKey(key$38)) ||
+            preloadPropsMap.set(key$41, pendingProps),
+            currentProps.querySelector(getStylesheetSelectorFromKey(key$41)) ||
               null !==
                 currentProps.querySelector(
-                  'link[rel="preload"][as="style"][' + key$38 + "]"
+                  'link[rel="preload"][as="style"][' + key$41 + "]"
                 ) ||
-              ((key$38 = currentProps.createElement("link")),
-              setInitialProperties(key$38, "link", pendingProps),
-              markNodeAsHoistable(key$38),
-              currentProps.head.appendChild(key$38))));
+              ((key$41 = currentProps.createElement("link")),
+              setInitialProperties(key$41, "link", pendingProps),
+              markNodeAsHoistable(key$41),
+              currentProps.head.appendChild(key$41))));
         return type;
       }
       return null;
@@ -4368,14 +4717,14 @@ function acquireResource(hoistableRoot, resource, props) {
         return (resource.instance = key);
       case "stylesheet":
         styleProps = getStyleKey(props.href);
-        var instance$45 = hoistableRoot.querySelector(
+        var instance$48 = hoistableRoot.querySelector(
           getStylesheetSelectorFromKey(styleProps)
         );
-        if (instance$45)
+        if (instance$48)
           return (
-            (resource.instance = instance$45),
-            markNodeAsHoistable(instance$45),
-            instance$45
+            (resource.instance = instance$48),
+            markNodeAsHoistable(instance$48),
+            instance$48
           );
         key = assign({}, props, {
           "data-precedence": props.precedence,
@@ -4383,11 +4732,11 @@ function acquireResource(hoistableRoot, resource, props) {
         });
         (styleProps = preloadPropsMap.get(styleProps)) &&
           adoptPreloadPropsForStylesheet(key, styleProps);
-        instance$45 = (
+        instance$48 = (
           hoistableRoot.ownerDocument || hoistableRoot
         ).createElement("link");
-        markNodeAsHoistable(instance$45);
-        var linkInstance = instance$45;
+        markNodeAsHoistable(instance$48);
+        var linkInstance = instance$48;
         linkInstance._p = new Promise(function (resolve, reject) {
           linkInstance.onload = resolve;
           linkInstance.onerror = reject;
@@ -4399,14 +4748,14 @@ function acquireResource(hoistableRoot, resource, props) {
             return (linkInstance._p.s = "e");
           }
         );
-        setInitialProperties(instance$45, "link", key);
-        insertStylesheet(instance$45, props.precedence, hoistableRoot);
-        return (resource.instance = instance$45);
+        setInitialProperties(instance$48, "link", key);
+        insertStylesheet(instance$48, props.precedence, hoistableRoot);
+        return (resource.instance = instance$48);
       case "script":
-        instance$45 = getScriptKey(props.src);
+        instance$48 = getScriptKey(props.src);
         if (
           (styleProps = hoistableRoot.querySelector(
-            "script[async]" + instance$45
+            "script[async]" + instance$48
           ))
         )
           return (
@@ -4415,7 +4764,7 @@ function acquireResource(hoistableRoot, resource, props) {
             styleProps
           );
         key = props;
-        if ((styleProps = preloadPropsMap.get(instance$45)))
+        if ((styleProps = preloadPropsMap.get(instance$48)))
           (key = assign({}, props)),
             adoptPreloadPropsForScript(key, styleProps);
         hoistableRoot = hoistableRoot.ownerDocument || hoistableRoot;
@@ -4528,7 +4877,11 @@ function shouldSetTextContent(type, props) {
 }
 var scheduleTimeout = "function" === typeof setTimeout ? setTimeout : void 0,
   cancelTimeout = "function" === typeof clearTimeout ? clearTimeout : void 0,
-  localPromise = "function" === typeof Promise ? Promise : void 0;
+  localPromise = "function" === typeof Promise ? Promise : void 0,
+  localRequestAnimationFrame =
+    "function" === typeof requestAnimationFrame
+      ? requestAnimationFrame
+      : scheduleTimeout;
 function getInstanceFromScope(scopeInstance) {
   scopeInstance = scopeInstance[internalInstanceKey] || null;
   return scopeInstance;
@@ -4730,6 +5083,13 @@ function setupIntersectionObserver(targets, callback, options) {
     }
   };
 }
+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;
@@ -5015,7 +5375,6 @@ function prepareToHydrateHostInstance(fiber) {
     props = fiber.memoizedProps;
   instance[internalInstanceKey] = fiber;
   instance[internalPropsKey] = props;
-  var isConcurrentMode = 0 !== (fiber.mode & 1);
   switch (type) {
     case "dialog":
       listenToNonDelegatedEvent("cancel", instance);
@@ -5056,34 +5415,30 @@ function prepareToHydrateHostInstance(fiber) {
         listenToNonDelegatedEvent("invalid", instance);
   }
   assertValidProps(type, props);
-  i = null;
-  for (var propKey in props)
-    if (props.hasOwnProperty(propKey)) {
-      var nextProp = props[propKey];
+  var updatePayload = null,
+    propKey;
+  for (propKey in props)
+    props.hasOwnProperty(propKey) &&
+      ((i = props[propKey]),
       "children" === propKey
-        ? "string" === typeof nextProp
-          ? instance.textContent !== nextProp &&
+        ? "string" === typeof i
+          ? instance.textContent !== i &&
             (!0 !== props.suppressHydrationWarning &&
-              checkForUnmatchedText(
-                instance.textContent,
-                nextProp,
-                isConcurrentMode
-              ),
-            (i = ["children", nextProp]))
-          : "number" === typeof nextProp &&
-            instance.textContent !== "" + nextProp &&
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", i]))
+          : "number" === typeof i &&
+            instance.textContent !== "" + i &&
             (!0 !== props.suppressHydrationWarning &&
-              checkForUnmatchedText(
-                instance.textContent,
-                nextProp,
-                isConcurrentMode
-              ),
-            (i = ["children", "" + nextProp]))
+              ((updatePayload = instance.textContent),
+              normalizeMarkupForTextOrAttribute(i),
+              normalizeMarkupForTextOrAttribute(updatePayload)),
+            (updatePayload = ["children", "" + i]))
         : registrationNameDependencies.hasOwnProperty(propKey) &&
-          null != nextProp &&
+          null != i &&
           "onScroll" === propKey &&
-          listenToNonDelegatedEvent("scroll", instance);
-    }
+          listenToNonDelegatedEvent("scroll", instance));
   switch (type) {
     case "input":
       track(instance);
@@ -5099,7 +5454,7 @@ function prepareToHydrateHostInstance(fiber) {
     default:
       "function" === typeof props.onClick && (instance.onclick = noop$1);
   }
-  instance = i;
+  instance = updatePayload;
   fiber.updateQueue = instance;
   return null !== instance ? !0 : !1;
 }
@@ -5282,18 +5637,22 @@ function enqueueUpdate(fiber, update, lane) {
   var updateQueue = fiber.updateQueue;
   if (null === updateQueue) return null;
   updateQueue = updateQueue.shared;
-  if (0 !== (executionContext & 2)) {
-    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;
-  }
-  enqueueUpdate$1(fiber, updateQueue, update, lane);
-  return getRootForUpdatedFiber(fiber);
+  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;
@@ -6415,19 +6774,19 @@ function renderWithHooks(
       ? HooksDispatcherOnMount
       : HooksDispatcherOnUpdate;
   shouldDoubleInvokeUserFnsInHooksDEV = !1;
-  current = Component(props, secondArg);
+  nextRenderLanes = Component(props, secondArg);
   shouldDoubleInvokeUserFnsInHooksDEV = !1;
   didScheduleRenderPhaseUpdateDuringThisPass &&
-    (current = renderWithHooksAgain(
+    (nextRenderLanes = renderWithHooksAgain(
       workInProgress,
       Component,
       props,
       secondArg
     ));
-  finishRenderingHooks();
-  return current;
+  finishRenderingHooks(current);
+  return nextRenderLanes;
 }
-function finishRenderingHooks() {
+function finishRenderingHooks(current) {
   ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
   var didRenderTooFewHooks = null !== currentHook && null !== currentHook.next;
   renderLanes$1 = 0;
@@ -6436,6 +6795,13 @@ function finishRenderingHooks() {
   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;
@@ -6526,15 +6892,15 @@ function updateWorkInProgressHook() {
 }
 var createFunctionComponentUpdateQueue;
 createFunctionComponentUpdateQueue = function () {
-  return { lastEffect: null, events: null, stores: null };
+  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$84 = thenableIndexCounter;
+      var index$88 = thenableIndexCounter;
       thenableIndexCounter += 1;
       null === thenableState && (thenableState = []);
-      usable = trackUsedThenable(thenableState, usable, index$84);
+      usable = trackUsedThenable(thenableState, usable, index$88);
       null === currentlyRenderingFiber$1.alternate &&
         (null === workInProgressHook
           ? null === currentlyRenderingFiber$1.memoizedState
@@ -6550,6 +6916,40 @@ function use(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;
 }
@@ -6875,6 +7275,28 @@ function mountEffect(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);
 }
@@ -6937,13 +7359,18 @@ function updateDeferredValueImpl(hook, prevValue, value) {
     (hook.baseState = !0));
   return prevValue;
 }
-function startTransition(setPending, callback) {
+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 {
@@ -6964,16 +7391,16 @@ function refreshCache(fiber, seedKey, seedValue) {
       case 3:
         var lane = requestUpdateLane(provider);
         fiber = createUpdate(lane);
-        var root$89 = enqueueUpdate(provider, fiber, lane);
-        if (null !== root$89) {
+        var root$94 = enqueueUpdate(provider, fiber, lane);
+        if (null !== root$94) {
           var eventTime = requestEventTime();
-          scheduleUpdateOnFiber(root$89, provider, lane, eventTime);
-          entangleTransitions(root$89, provider, lane);
+          scheduleUpdateOnFiber(root$94, provider, lane, eventTime);
+          entangleTransitions(root$94, provider, lane);
         }
         provider = createCache();
         null !== seedKey &&
           void 0 !== seedKey &&
-          null !== root$89 &&
+          null !== root$94 &&
           provider.data.set(seedKey, seedValue);
         fiber.payload = { cache: provider };
         return;
@@ -7085,6 +7512,8 @@ var ContextOnlyDispatcher = {
 };
 ContextOnlyDispatcher.useCacheRefresh = throwInvalidHookError;
 ContextOnlyDispatcher.use = throwInvalidHookError;
+ContextOnlyDispatcher.useMemoCache = throwInvalidHookError;
+ContextOnlyDispatcher.useEffectEvent = throwInvalidHookError;
 var HooksDispatcherOnMount = {
   readContext: readContext,
   useCallback: function (callback, deps) {
@@ -7140,6 +7569,11 @@ var HooksDispatcherOnMount = {
   },
   useRef: function (initialValue) {
     var hook = mountWorkInProgressHook();
+    if (enableUseRefAccessWarning)
+      return (
+        (initialValue = { current: initialValue }),
+        (hook.memoizedState = initialValue)
+      );
     initialValue = { current: initialValue };
     return (hook.memoizedState = initialValue);
   },
@@ -7173,15 +7607,15 @@ var HooksDispatcherOnMount = {
       getServerSnapshot = getServerSnapshot();
     } else {
       getServerSnapshot = getSnapshot();
-      var root$86 = workInProgressRoot;
-      if (null === root$86) throw Error(formatProdErrorMessage(349));
-      includesBlockingLane(root$86, renderLanes$1) ||
+      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$86 = { value: getServerSnapshot, getSnapshot: getSnapshot };
-    hook.queue = root$86;
-    mountEffect(subscribeToStore.bind(null, fiber, root$86, subscribe), [
+    root$90 = { value: getServerSnapshot, getSnapshot: getSnapshot };
+    hook.queue = root$90;
+    mountEffect(subscribeToStore.bind(null, fiber, root$90, subscribe), [
       subscribe
     ]);
     fiber.flags |= 2048;
@@ -7190,7 +7624,7 @@ var HooksDispatcherOnMount = {
       updateStoreInstance.bind(
         null,
         fiber,
-        root$86,
+        root$90,
         getServerSnapshot,
         getSnapshot
       ),
@@ -7233,6 +7667,16 @@ var HooksDispatcherOnMount = {
   }
 };
 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,
@@ -7262,7 +7706,9 @@ var HooksDispatcherOnUpdate = {
   useId: updateId
 };
 HooksDispatcherOnUpdate.useCacheRefresh = updateRefresh;
+HooksDispatcherOnUpdate.useMemoCache = useMemoCache;
 HooksDispatcherOnUpdate.use = use;
+HooksDispatcherOnUpdate.useEffectEvent = updateEvent;
 var HooksDispatcherOnRerender = {
   readContext: readContext,
   useCallback: updateCallback,
@@ -7295,6 +7741,8 @@ var HooksDispatcherOnRerender = {
 };
 HooksDispatcherOnRerender.useCacheRefresh = updateRefresh;
 HooksDispatcherOnRerender.use = use;
+HooksDispatcherOnRerender.useMemoCache = useMemoCache;
+HooksDispatcherOnRerender.useEffectEvent = updateEvent;
 function resolveDefaultProps(Component, baseProps) {
   if (Component && Component.defaultProps) {
     baseProps = assign({}, baseProps);
@@ -7480,9 +7928,9 @@ function logCapturedError(boundary, errorInfo) {
         errorBoundary:
           null !== boundary && 1 === boundary.tag ? boundary.stateNode : null
       }) && console.error(errorInfo.value);
-  } catch (e$94) {
+  } catch (e$99) {
     setTimeout(function () {
-      throw e$94;
+      throw e$99;
     });
   }
 }
@@ -7553,6 +8001,143 @@ function markSuspenseBoundaryShouldCapture(
   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;
@@ -7636,7 +8221,7 @@ function updateMemoComponent(
     return (workInProgress.child = current);
   }
   type = current.child;
-  if (0 === (current.lanes & renderLanes)) {
+  if (!checkScheduledUpdateOrContext(current, renderLanes)) {
     var prevProps = type.memoizedProps;
     Component = Component.compare;
     Component = null !== Component ? Component : shallowEqual;
@@ -7665,7 +8250,7 @@ function updateSimpleMemoComponent(
       if (
         ((didReceiveUpdate = !1),
         (workInProgress.pendingProps = nextProps = prevProps),
-        0 !== (current.lanes & renderLanes))
+        checkScheduledUpdateOrContext(current, renderLanes))
       )
         0 !== (current.flags & 131072) && (didReceiveUpdate = !0);
       else
@@ -7688,27 +8273,31 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
     nextIsDetached = 0 !== (workInProgress.stateNode._pendingVisibility & 2),
     prevState = null !== current ? current.memoizedState : null;
   markRef$1(current, workInProgress);
-  if ("hidden" === nextProps.mode || nextIsDetached) {
+  if (
+    "hidden" === nextProps.mode ||
+    "unstable-defer-without-hiding" === nextProps.mode ||
+    nextIsDetached
+  ) {
     if (0 !== (workInProgress.flags & 128)) {
-      renderLanes =
+      nextChildren =
         null !== prevState ? prevState.baseLanes | renderLanes : renderLanes;
       if (null !== current) {
-        nextProps = workInProgress.child = current.child;
-        for (nextChildren = 0; null !== nextProps; )
-          (nextChildren =
-            nextChildren | nextProps.lanes | nextProps.childLanes),
-            (nextProps = nextProps.sibling);
-        workInProgress.childLanes = nextChildren & ~renderLanes;
+        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 !== current && pushTransition(workInProgress, null, null),
         reuseHiddenContextOnStack(),
         pushOffscreenSuspenseHandler(workInProgress);
     else if (0 !== (renderLanes & 1073741824))
@@ -7716,7 +8305,8 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         null !== current &&
           pushTransition(
             workInProgress,
-            null !== prevState ? prevState.cachePool : null
+            null !== prevState ? prevState.cachePool : null,
+            null
           ),
         null !== prevState
           ? pushHiddenContext(workInProgress, prevState)
@@ -7728,22 +8318,36 @@ function updateOffscreenComponent(current, workInProgress, renderLanes) {
         deferHiddenOffscreenComponent(
           current,
           workInProgress,
-          null !== prevState ? prevState.baseLanes | renderLanes : renderLanes
+          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 !== prevState
-      ? (pushTransition(workInProgress, prevState.cachePool),
-        pushHiddenContext(workInProgress, prevState),
-        reuseSuspenseHandlerOnStack(),
-        (workInProgress.memoizedState = null))
-      : (null !== current && pushTransition(workInProgress, null),
-        reuseHiddenContextOnStack(),
-        reuseSuspenseHandlerOnStack());
+    null !== current && pushTransition(workInProgress, null, null),
+      reuseHiddenContextOnStack(),
+      reuseSuspenseHandlerOnStack();
   reconcileChildren(current, workInProgress, nextChildren, renderLanes);
   return workInProgress.child;
 }
-function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes) {
+function deferHiddenOffscreenComponent(
+  current,
+  workInProgress,
+  nextBaseLanes,
+  renderLanes
+) {
   var JSCompiler_inline_result = peekCacheFromPool();
   JSCompiler_inline_result =
     null === JSCompiler_inline_result
@@ -7753,9 +8357,12 @@ function deferHiddenOffscreenComponent(current, workInProgress, nextBaseLanes) {
     baseLanes: nextBaseLanes,
     cachePool: JSCompiler_inline_result
   };
-  null !== current && pushTransition(workInProgress, null);
+  null !== current && pushTransition(workInProgress, null, null);
   reuseHiddenContextOnStack();
   pushOffscreenSuspenseHandler(workInProgress);
+  enableLazyContextPropagation &&
+    null !== current &&
+    propagateParentContextChanges(current, workInProgress, renderLanes, !0);
   return null;
 }
 function markRef$1(current, workInProgress) {
@@ -7807,7 +8414,7 @@ function replayFunctionComponent(
     nextProps,
     void 0
   );
-  finishRenderingHooks();
+  finishRenderingHooks(current);
   Component = checkDidRenderIdHook();
   if (null !== current && !didReceiveUpdate)
     return (
@@ -7937,7 +8544,11 @@ function updateClassComponent(
     var newState = workInProgress.memoizedState;
     nextContext !== getDerivedStateFromProps ||
     oldContext$jscomp$0 !== newState ||
-    hasForceUpdate
+    hasForceUpdate ||
+    (enableLazyContextPropagation &&
+      null !== current &&
+      null !== current.dependencies &&
+      checkIfContextChanged(current.dependencies))
       ? ("function" === typeof oldState &&
           (applyDerivedStateFromProps(
             workInProgress,
@@ -7957,7 +8568,10 @@ function updateClassComponent(
             newState,
             oldProps
           ) ||
-          !1)
+          (enableLazyContextPropagation &&
+            null !== current &&
+            null !== current.dependencies &&
+            checkIfContextChanged(current.dependencies)))
           ? (oldContext ||
               ("function" !== typeof instance.UNSAFE_componentWillUpdate &&
                 "function" !== typeof instance.componentWillUpdate) ||
@@ -8131,9 +8745,26 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
           didSuspend,
           renderLanes
         )),
-        (workInProgress.child.memoizedState =
-          mountSuspenseOffscreenState(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)
@@ -8156,14 +8787,14 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
   }
   JSCompiler_temp = current.memoizedState;
   if (null !== JSCompiler_temp) {
-    var dehydrated$106 = JSCompiler_temp.dehydrated;
-    if (null !== dehydrated$106)
+    var dehydrated$112 = JSCompiler_temp.dehydrated;
+    if (null !== dehydrated$112)
       return updateDehydratedSuspenseComponent(
         current,
         workInProgress,
         didSuspend,
         nextProps,
-        dehydrated$106,
+        dehydrated$112,
         JSCompiler_temp,
         renderLanes
       );
@@ -8173,7 +8804,7 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
     showFallback = nextProps.fallback;
     didSuspend = workInProgress.mode;
     JSCompiler_temp = current.child;
-    dehydrated$106 = JSCompiler_temp.sibling;
+    dehydrated$112 = JSCompiler_temp.sibling;
     var primaryChildProps = { mode: "hidden", children: nextProps.children };
     0 === (didSuspend & 1) && workInProgress.child !== JSCompiler_temp
       ? ((nextProps = workInProgress.child),
@@ -8182,8 +8813,8 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
         (workInProgress.deletions = null))
       : ((nextProps = createWorkInProgress(JSCompiler_temp, primaryChildProps)),
         (nextProps.subtreeFlags = JSCompiler_temp.subtreeFlags & 14680064));
-    null !== dehydrated$106
-      ? (showFallback = createWorkInProgress(dehydrated$106, showFallback))
+    null !== dehydrated$112
+      ? (showFallback = createWorkInProgress(dehydrated$112, showFallback))
       : ((showFallback = createFiberFromFragment(
           showFallback,
           didSuspend,
@@ -8202,10 +8833,10 @@ function updateSuspenseComponent(current, workInProgress, renderLanes) {
       ? (didSuspend = mountSuspenseOffscreenState(renderLanes))
       : ((JSCompiler_temp = didSuspend.cachePool),
         null !== JSCompiler_temp
-          ? ((dehydrated$106 = CacheContext._currentValue),
+          ? ((dehydrated$112 = CacheContext._currentValue),
             (JSCompiler_temp =
-              JSCompiler_temp.parent !== dehydrated$106
-                ? { parent: dehydrated$106, pool: dehydrated$106 }
+              JSCompiler_temp.parent !== dehydrated$112
+                ? { parent: dehydrated$112, pool: dehydrated$112 }
                 : JSCompiler_temp))
           : (JSCompiler_temp = getSuspendedCache()),
         (didSuspend = {
@@ -8213,6 +8844,29 @@ function updateSuspenseComponent(current, workInProgress, 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;
@@ -8373,12 +9027,16 @@ function updateDehydratedSuspenseComponent(
       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 (0 !== (suspenseInstance & 42)) suspenseInstance = 1;
+      if (enableUnifiedSyncLane && 0 !== (suspenseInstance & 42))
+        suspenseInstance = 1;
       else
         switch (suspenseInstance) {
           case 2:
@@ -8596,7 +9254,19 @@ function resetSuspendedCurrentOnMountInLegacyMode(current, workInProgress) {
 function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
   null !== current && (workInProgress.dependencies = current.dependencies);
   workInProgressRootSkippedLanes |= workInProgress.lanes;
-  if (0 === (renderLanes & workInProgress.childLanes)) return null;
+  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) {
@@ -8612,6 +9282,14 @@ function bailoutOnAlreadyFinishedWork(current, workInProgress, renderLanes) {
   }
   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,
@@ -8620,6 +9298,9 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
   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;
@@ -8659,8 +9340,18 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
       pushPrimaryTreeSuspenseHandler(workInProgress);
       break;
     case 19:
+      var didSuspendBefore = 0 !== (current.flags & 128);
       state = 0 !== (renderLanes & workInProgress.childLanes);
-      if (0 !== (current.flags & 128)) {
+      enableLazyContextPropagation &&
+        !state &&
+        (propagateParentContextChanges(
+          current,
+          workInProgress,
+          renderLanes,
+          !1
+        ),
+        (state = 0 !== (renderLanes & workInProgress.childLanes)));
+      if (didSuspendBefore) {
         if (state)
           return updateSuspenseListComponent(
             current,
@@ -8669,11 +9360,11 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
           );
         workInProgress.flags |= 128;
       }
-      var renderState = workInProgress.memoizedState;
-      null !== renderState &&
-        ((renderState.rendering = null),
-        (renderState.tail = null),
-        (renderState.lastEffect = null));
+      didSuspendBefore = workInProgress.memoizedState;
+      null !== didSuspendBefore &&
+        ((didSuspendBefore.rendering = null),
+        (didSuspendBefore.tail = null),
+        (didSuspendBefore.lastEffect = null));
       push(suspenseStackCursor, suspenseStackCursor.current);
       if (state) break;
       else return null;
@@ -8685,6 +9376,11 @@ function attemptEarlyBailoutIfNoScheduledUpdate(
       );
     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);
 }
@@ -8724,78 +9420,200 @@ function scheduleContextWorkOnParentPath(parent, renderLanes, propagationRoot) {
   }
 }
 function propagateContextChange(workInProgress, context, renderLanes) {
-  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;
+  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;
           }
-          fiber.lanes |= renderLanes;
-          dependency = fiber.alternate;
-          null !== dependency && (dependency.lanes |= renderLanes);
-          scheduleContextWorkOnParentPath(
-            fiber.return,
-            renderLanes,
-            workInProgress
-          );
-          list.lanes |= renderLanes;
-          break;
+          dependency = dependency.next;
         }
-        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;
+      } 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.sibling;
-        if (null !== fiber) {
-          fiber.return = nextFiber.return;
-          nextFiber = fiber;
-          break;
+      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;
+          }
+          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]));
         }
-        nextFiber = nextFiber.return;
       }
-    fiber = nextFiber;
+      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 &&
-    null !== workInProgress.firstContext &&
-    (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
-    (workInProgress.firstContext = null));
+    (enableLazyContextPropagation
+      ? (workInProgress.firstContext = null)
+      : null !== workInProgress.firstContext &&
+        (0 !== (workInProgress.lanes & renderLanes) && (didReceiveUpdate = !0),
+        (workInProgress.firstContext = null)));
 }
 function readContext(context) {
   return readContextForConsumer(currentlyRenderingFiber, context);
@@ -8815,6 +9633,7 @@ function readContextForConsumer(consumer, context) {
       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;
 }
@@ -8863,17 +9682,32 @@ function releaseCache(cache) {
     });
 }
 var ReactCurrentBatchConfig$1 = ReactSharedInternals.ReactCurrentBatchConfig,
-  resumedCache = createCursor(null);
+  resumedCache = createCursor(null),
+  transitionStack = createCursor(null);
 function peekCacheFromPool() {
   var cacheResumedFromPreviousRender = resumedCache.current;
   return null !== cacheResumedFromPreviousRender
     ? cacheResumedFromPreviousRender
     : workInProgressRoot.pooledCache;
 }
-function pushTransition(offscreenWorkInProgress, prevCachePool) {
+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();
@@ -9120,14 +9954,14 @@ function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
         break;
       case "collapsed":
         lastTailNode = renderState.tail;
-        for (var lastTailNode$131 = null; null !== lastTailNode; )
-          null !== lastTailNode.alternate && (lastTailNode$131 = lastTailNode),
+        for (var lastTailNode$143 = null; null !== lastTailNode; )
+          null !== lastTailNode.alternate && (lastTailNode$143 = lastTailNode),
             (lastTailNode = lastTailNode.sibling);
-        null === lastTailNode$131
+        null === lastTailNode$143
           ? hasRenderedATailFallback || null === renderState.tail
             ? (renderState.tail = null)
             : (renderState.tail.sibling = null)
-          : (lastTailNode$131.sibling = null);
+          : (lastTailNode$143.sibling = null);
     }
 }
 function bubbleProperties(completedWork) {
@@ -9137,19 +9971,19 @@ function bubbleProperties(completedWork) {
     newChildLanes = 0,
     subtreeFlags = 0;
   if (didBailout)
-    for (var child$132 = completedWork.child; null !== child$132; )
-      (newChildLanes |= child$132.lanes | child$132.childLanes),
-        (subtreeFlags |= child$132.subtreeFlags & 14680064),
-        (subtreeFlags |= child$132.flags & 14680064),
-        (child$132.return = completedWork),
-        (child$132 = child$132.sibling);
+    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$132 = completedWork.child; null !== child$132; )
-      (newChildLanes |= child$132.lanes | child$132.childLanes),
-        (subtreeFlags |= child$132.subtreeFlags),
-        (subtreeFlags |= child$132.flags),
-        (child$132.return = completedWork),
-        (child$132 = child$132.sibling);
+    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;
@@ -9173,11 +10007,18 @@ function completeWork(current, workInProgress, renderLanes) {
       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 &&
@@ -9194,6 +10035,9 @@ function completeWork(current, workInProgress, renderLanes) {
               (queueRecoverableErrors(hydrationErrors),
               (hydrationErrors = null)));
       bubbleProperties(workInProgress);
+      enableTransitionTracing &&
+        0 !== (workInProgress.subtreeFlags & 8192) &&
+        (workInProgress.flags |= 2048);
       return null;
     case 26:
       return (
@@ -9346,29 +10190,25 @@ function completeWork(current, workInProgress, renderLanes) {
           throw Error(formatProdErrorMessage(166));
         current = rootInstanceStackCursor.current;
         if (popHydrationState(workInProgress)) {
-          current = workInProgress.stateNode;
-          renderLanes = workInProgress.memoizedProps;
-          current[internalInstanceKey] = workInProgress;
-          if ((newProps = current.nodeValue !== renderLanes))
+          newProps = workInProgress.stateNode;
+          current = workInProgress.memoizedProps;
+          newProps[internalInstanceKey] = workInProgress;
+          if ((renderLanes = newProps.nodeValue !== current))
             if (((type = hydrationParentFiber), null !== type))
               switch (type.tag) {
                 case 3:
-                  checkForUnmatchedText(
-                    current.nodeValue,
-                    renderLanes,
-                    0 !== (type.mode & 1)
-                  );
+                  newProps = newProps.nodeValue;
+                  normalizeMarkupForTextOrAttribute(current);
+                  normalizeMarkupForTextOrAttribute(newProps);
                   break;
                 case 27:
                 case 5:
                   !0 !== type.memoizedProps.suppressHydrationWarning &&
-                    checkForUnmatchedText(
-                      current.nodeValue,
-                      renderLanes,
-                      0 !== (type.mode & 1)
-                    );
+                    ((newProps = newProps.nodeValue),
+                    normalizeMarkupForTextOrAttribute(current),
+                    normalizeMarkupForTextOrAttribute(newProps));
               }
-          newProps && markUpdate(workInProgress);
+          renderLanes && markUpdate(workInProgress);
         } else
           (current =
             getOwnerDocumentFromRootContainer(current).createTextNode(
@@ -9431,15 +10271,15 @@ function completeWork(current, workInProgress, renderLanes) {
           null !== newProps.alternate.memoizedState &&
           null !== newProps.alternate.memoizedState.cachePool &&
           (type = newProps.alternate.memoizedState.cachePool.pool);
-        var cache$142 = null;
+        var cache$154 = null;
         null !== newProps.memoizedState &&
           null !== newProps.memoizedState.cachePool &&
-          (cache$142 = newProps.memoizedState.cachePool.pool);
-        cache$142 !== type && (newProps.flags |= 2048);
+          (cache$154 = newProps.memoizedState.cachePool.pool);
+        cache$154 !== type && (newProps.flags |= 2048);
       }
       renderLanes !== current &&
-        renderLanes &&
-        (workInProgress.child.flags |= 8192);
+        (enableTransitionTracing && (workInProgress.child.flags |= 2048),
+        renderLanes && (workInProgress.child.flags |= 8192));
       null !== workInProgress.updateQueue && (workInProgress.flags |= 4);
       null !== workInProgress.updateQueue &&
         null != workInProgress.memoizedProps.suspenseCallback &&
@@ -9467,8 +10307,8 @@ function completeWork(current, workInProgress, renderLanes) {
       type = workInProgress.memoizedState;
       if (null === type) return bubbleProperties(workInProgress), null;
       newProps = 0 !== (workInProgress.flags & 128);
-      cache$142 = type.rendering;
-      if (null === cache$142)
+      cache$154 = type.rendering;
+      if (null === cache$154)
         if (newProps) cutOffTailIfNeeded(type, !1);
         else {
           if (
@@ -9476,11 +10316,11 @@ function completeWork(current, workInProgress, renderLanes) {
             (null !== current && 0 !== (current.flags & 128))
           )
             for (current = workInProgress.child; null !== current; ) {
-              cache$142 = findFirstSuspended(current);
-              if (null !== cache$142) {
+              cache$154 = findFirstSuspended(current);
+              if (null !== cache$154) {
                 workInProgress.flags |= 128;
                 cutOffTailIfNeeded(type, !1);
-                current = cache$142.updateQueue;
+                current = cache$154.updateQueue;
                 null !== current &&
                   ((workInProgress.updateQueue = current),
                   (workInProgress.flags |= 4));
@@ -9506,7 +10346,7 @@ function completeWork(current, workInProgress, renderLanes) {
         }
       else {
         if (!newProps)
-          if (((current = findFirstSuspended(cache$142)), null !== current)) {
+          if (((current = findFirstSuspended(cache$154)), null !== current)) {
             if (
               ((workInProgress.flags |= 128),
               (newProps = !0),
@@ -9517,7 +10357,7 @@ function completeWork(current, workInProgress, renderLanes) {
               cutOffTailIfNeeded(type, !0),
               null === type.tail &&
                 "hidden" === type.tailMode &&
-                !cache$142.alternate &&
+                !cache$154.alternate &&
                 !isHydrating)
             )
               return bubbleProperties(workInProgress), null;
@@ -9530,13 +10370,13 @@ function completeWork(current, workInProgress, renderLanes) {
               cutOffTailIfNeeded(type, !1),
               (workInProgress.lanes = 8388608));
         type.isBackwards
-          ? ((cache$142.sibling = workInProgress.child),
-            (workInProgress.child = cache$142))
+          ? ((cache$154.sibling = workInProgress.child),
+            (workInProgress.child = cache$154))
           : ((current = type.last),
             null !== current
-              ? (current.sibling = cache$142)
-              : (workInProgress.child = cache$142),
-            (type.last = cache$142));
+              ? (current.sibling = cache$154)
+              : (workInProgress.child = cache$154),
+            (type.last = cache$154));
       }
       if (null !== type.tail)
         return (
@@ -9575,15 +10415,18 @@ function completeWork(current, workInProgress, renderLanes) {
         popSuspenseHandler(workInProgress),
         popHiddenContext(),
         (newProps = null !== workInProgress.memoizedState),
-        null !== current
-          ? (null !== current.memoizedState) !== newProps &&
-            (workInProgress.flags |= 8192)
-          : newProps && (workInProgress.flags |= 8192),
+        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),
-            workInProgress.subtreeFlags & 6 && (workInProgress.flags |= 8192))
+            23 !== workInProgress.tag &&
+              workInProgress.subtreeFlags & 6 &&
+              (workInProgress.flags |= 8192))
           : bubbleProperties(workInProgress),
         null !== workInProgress.updateQueue && (workInProgress.flags |= 4),
         (renderLanes = null),
@@ -9596,7 +10439,7 @@ function completeWork(current, workInProgress, renderLanes) {
           null !== workInProgress.memoizedState.cachePool &&
           (newProps = workInProgress.memoizedState.cachePool.pool),
         newProps !== renderLanes && (workInProgress.flags |= 2048),
-        null !== current && pop(resumedCache),
+        popTransition(workInProgress, current),
         null
       );
     case 24:
@@ -9610,7 +10453,14 @@ function completeWork(current, workInProgress, renderLanes) {
         null
       );
     case 25:
-      return null;
+      return (
+        enableTransitionTracing &&
+          (null !== workInProgress.stateNode &&
+            enableTransitionTracing &&
+            pop(markerInstanceStack),
+          bubbleProperties(workInProgress)),
+        null
+      );
   }
   throw Error(formatProdErrorMessage(156, workInProgress.tag));
 }
@@ -9627,6 +10477,10 @@ function unwindWork(current, workInProgress) {
     case 3:
       return (
         popProvider(CacheContext),
+        enableTransitionTracing &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        enableTransitionTracing && pop(transitionStack),
         popHostContainer(),
         resetWorkInProgressVersions(),
         (current = workInProgress.flags),
@@ -9661,7 +10515,7 @@ function unwindWork(current, workInProgress) {
       return (
         popSuspenseHandler(workInProgress),
         popHiddenContext(),
-        null !== current && pop(resumedCache),
+        popTransition(workInProgress, current),
         (current = workInProgress.flags),
         current & 65536
           ? ((workInProgress.flags = (current & -65537) | 128), workInProgress)
@@ -9670,7 +10524,13 @@ function unwindWork(current, workInProgress) {
     case 24:
       return popProvider(CacheContext), null;
     case 25:
-      return null;
+      return (
+        enableTransitionTracing &&
+          null !== workInProgress.stateNode &&
+          enableTransitionTracing &&
+          pop(markerInstanceStack),
+        null
+      );
     default:
       return null;
   }
@@ -9680,6 +10540,10 @@ function unwindInterruptedWork(current, interruptedWork) {
   switch (interruptedWork.tag) {
     case 3:
       popProvider(CacheContext);
+      enableTransitionTracing &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
+      enableTransitionTracing && pop(transitionStack);
       popHostContainer();
       resetWorkInProgressVersions();
       break;
@@ -9704,10 +10568,16 @@ function unwindInterruptedWork(current, interruptedWork) {
     case 23:
       popSuspenseHandler(interruptedWork);
       popHiddenContext();
-      null !== current && pop(resumedCache);
+      popTransition(interruptedWork, current);
       break;
     case 24:
       popProvider(CacheContext);
+      break;
+    case 25:
+      enableTransitionTracing &&
+        null !== interruptedWork.stateNode &&
+        enableTransitionTracing &&
+        pop(markerInstanceStack);
   }
 }
 var offscreenSubtreeIsHidden = !1,
@@ -9754,8 +10624,8 @@ function safelyDetachRef(current, nearestMountedAncestor) {
     else if ("function" === typeof ref)
       try {
         ref(null);
-      } catch (error$155) {
-        captureCommitPhaseError(current, nearestMountedAncestor, error$155);
+      } catch (error$169) {
+        captureCommitPhaseError(current, nearestMountedAncestor, error$169);
       }
     else ref.current = null;
 }
@@ -9792,7 +10662,7 @@ function commitBeforeMutationEffects(root, firstChild) {
           selection = selection.focusOffset;
           try {
             JSCompiler_temp.nodeType, focusNode.nodeType;
-          } catch (e$22) {
+          } catch (e$25) {
             JSCompiler_temp = null;
             break a;
           }
@@ -9901,6 +10771,16 @@ function commitBeforeMutationEffects(root, firstChild) {
             (_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:
@@ -10065,11 +10945,11 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
               current,
               finishedRoot.__reactInternalSnapshotBeforeUpdate
             );
-          } catch (error$157) {
+          } catch (error$171) {
             captureCommitPhaseError(
               finishedWork,
               finishedWork.return,
-              error$157
+              error$171
             );
           }
         }
@@ -10147,6 +11027,190 @@ function commitLayoutEffectOnFiber(finishedRoot, current, finishedWork) {
       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
+                    );
+                  })));
+        });
+  }
+}
 function detachFiberAfterEffects(fiber) {
   var alternate = fiber.alternate;
   null !== alternate &&
@@ -10468,6 +11532,26 @@ function getRetryCache(finishedWork) {
       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 attachSuspenseRetryListeners(finishedWork, wakeables) {
   var retryCache = getRetryCache(finishedWork);
   wakeables.forEach(function (wakeable) {
@@ -10539,8 +11623,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         }
         try {
           commitHookEffectListUnmount(5, finishedWork, finishedWork.return);
-        } catch (error$169) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$169);
+        } catch (error$184) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$184);
         }
       }
       break;
@@ -10718,11 +11802,11 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
               newProps
             );
             domElement[internalPropsKey] = newProps;
-          } catch (error$170) {
+          } catch (error$185) {
             captureCommitPhaseError(
               finishedWork,
               finishedWork.return,
-              error$170
+              error$185
             );
           }
       break;
@@ -10758,8 +11842,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         root = finishedWork.stateNode;
         try {
           setTextContent(root, "");
-        } catch (error$171) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$171);
+        } catch (error$186) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$186);
         }
       }
       if (
@@ -10776,8 +11860,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         try {
           updateProperties(flags, maybeNodes, hoistableRoot, current, root),
             (flags[internalPropsKey] = root);
-        } catch (error$174) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$174);
+        } catch (error$189) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$189);
         }
       break;
     case 6:
@@ -10790,8 +11874,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
         flags = finishedWork.memoizedProps;
         try {
           current.nodeValue = flags;
-        } catch (error$175) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$175);
+        } catch (error$190) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$190);
         }
       }
       break;
@@ -10805,8 +11889,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
       if (flags & 4 && null !== current && current.memoizedState.isDehydrated)
         try {
           retryIfBlockedOn(root.containerInfo);
-        } catch (error$176) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$176);
+        } catch (error$191) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$191);
         }
       break;
     case 4:
@@ -10836,8 +11920,8 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
               null !== wakeables && suspenseCallback(new Set(wakeables));
             }
           }
-        } catch (error$178) {
-          captureCommitPhaseError(finishedWork, finishedWork.return, error$178);
+        } catch (error$193) {
+          captureCommitPhaseError(finishedWork, finishedWork.return, error$193);
         }
         current = finishedWork.updateQueue;
         null !== current &&
@@ -10915,11 +11999,11 @@ function commitMutationEffectsOnFiber(finishedWork, root) {
             if (null === current)
               try {
                 root.stateNode.nodeValue = domElement ? "" : root.memoizedProps;
-              } catch (error$159) {
+              } catch (error$174) {
                 captureCommitPhaseError(
                   finishedWork,
                   finishedWork.return,
-                  error$159
+                  error$174
                 );
               }
           } else if (
@@ -10994,21 +12078,21 @@ function commitReconciliationEffects(finishedWork) {
             insertOrAppendPlacementNode(finishedWork, before, parent$jscomp$0);
             break;
           case 5:
-            var parent$160 = JSCompiler_inline_result.stateNode;
+            var parent$175 = JSCompiler_inline_result.stateNode;
             JSCompiler_inline_result.flags & 32 &&
-              (setTextContent(parent$160, ""),
+              (setTextContent(parent$175, ""),
               (JSCompiler_inline_result.flags &= -33));
-            var before$161 = getHostSibling(finishedWork);
-            insertOrAppendPlacementNode(finishedWork, before$161, parent$160);
+            var before$176 = getHostSibling(finishedWork);
+            insertOrAppendPlacementNode(finishedWork, before$176, parent$175);
             break;
           case 3:
           case 4:
-            var parent$162 = JSCompiler_inline_result.stateNode.containerInfo,
-              before$163 = getHostSibling(finishedWork);
+            var parent$177 = JSCompiler_inline_result.stateNode.containerInfo,
+              before$178 = getHostSibling(finishedWork);
             insertOrAppendPlacementNodeIntoContainer(
               finishedWork,
-              before$163,
-              parent$162
+              before$178,
+              parent$177
             );
             break;
           default:
@@ -11182,7 +12266,7 @@ function commitHookPassiveMountEffects(finishedWork, hookFlags) {
     captureCommitPhaseError(finishedWork, finishedWork.return, error);
   }
 }
-function commitOffscreenPassiveMountEffects(current, finishedWork) {
+function commitOffscreenPassiveMountEffects(current, finishedWork, instance) {
   var previousCache = null;
   null !== current &&
     null !== current.memoizedState &&
@@ -11195,6 +12279,41 @@ function commitOffscreenPassiveMountEffects(current, finishedWork) {
   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;
@@ -11204,6 +12323,19 @@ function commitCachePassiveMountEffect(current, finishedWork) {
   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,
@@ -11246,21 +12378,78 @@ function commitPassiveMountOnFiber(
         committedLanes,
         committedTransitions
       );
-      flags & 2048 &&
-        ((finishedRoot = null),
+      if (flags & 2048) {
+        flags = null;
         null !== finishedWork.alternate &&
-          (finishedRoot = finishedWork.alternate.memoizedState.cache),
-        (finishedWork = finishedWork.memoizedState.cache),
-        finishedWork !== finishedRoot &&
-          (finishedWork.refCount++,
-          null != finishedRoot && releaseCache(finishedRoot)));
+          (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:
-      var instance = finishedWork.stateNode;
+      nextCache = finishedWork.stateNode;
       null !== finishedWork.memoizedState
-        ? instance._visibility & 4
+        ? nextCache._visibility & 4
           ? recursivelyTraversePassiveMountEffects(
               finishedRoot,
               finishedWork,
@@ -11269,21 +12458,21 @@ function commitPassiveMountOnFiber(
             )
           : finishedWork.mode & 1
           ? recursivelyTraverseAtomicPassiveEffects(finishedRoot, finishedWork)
-          : ((instance._visibility |= 4),
+          : ((nextCache._visibility |= 4),
             recursivelyTraversePassiveMountEffects(
               finishedRoot,
               finishedWork,
               committedLanes,
               committedTransitions
             ))
-        : instance._visibility & 4
+        : nextCache._visibility & 4
         ? recursivelyTraversePassiveMountEffects(
             finishedRoot,
             finishedWork,
             committedLanes,
             committedTransitions
           )
-        : ((instance._visibility |= 4),
+        : ((nextCache._visibility |= 4),
           recursivelyTraverseReconnectPassiveEffects(
             finishedRoot,
             finishedWork,
@@ -11294,7 +12483,8 @@ function commitPassiveMountOnFiber(
       flags & 2048 &&
         commitOffscreenPassiveMountEffects(
           finishedWork.alternate,
-          finishedWork
+          finishedWork,
+          nextCache
         );
       break;
     case 24:
@@ -11307,6 +12497,17 @@ function commitPassiveMountOnFiber(
       flags & 2048 &&
         commitCachePassiveMountEffect(finishedWork.alternate, finishedWork);
       break;
+    case 25:
+      if (enableTransitionTracing) {
+        recursivelyTraversePassiveMountEffects(
+          finishedRoot,
+          finishedWork,
+          committedLanes,
+          committedTransitions
+        );
+        flags & 2048 && commitTracingMarkerPassiveMountEffect(finishedWork);
+        break;
+      }
     default:
       recursivelyTraversePassiveMountEffects(
         finishedRoot,
@@ -11345,11 +12546,25 @@ function recursivelyTraverseReconnectPassiveEffects(
         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 = finishedWork.stateNode;
+        var instance$203 = finishedWork.stateNode;
         null !== finishedWork.memoizedState
-          ? instance._visibility & 4
+          ? instance$203._visibility & 4
             ? recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork,
@@ -11362,7 +12577,7 @@ function recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork
               )
-            : ((instance._visibility |= 4),
+            : ((instance$203._visibility |= 4),
               recursivelyTraverseReconnectPassiveEffects(
                 finishedRoot,
                 finishedWork,
@@ -11370,7 +12585,7 @@ function recursivelyTraverseReconnectPassiveEffects(
                 committedTransitions,
                 includeWorkInProgressEffects
               ))
-          : ((instance._visibility |= 4),
+          : ((instance$203._visibility |= 4),
             recursivelyTraverseReconnectPassiveEffects(
               finishedRoot,
               finishedWork,
@@ -11382,7 +12597,8 @@ function recursivelyTraverseReconnectPassiveEffects(
           flags & 2048 &&
           commitOffscreenPassiveMountEffects(
             finishedWork.alternate,
-            finishedWork
+            finishedWork,
+            instance$203
           );
         break;
       case 24:
@@ -11397,6 +12613,20 @@ function recursivelyTraverseReconnectPassiveEffects(
           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,
@@ -11424,7 +12654,8 @@ function recursivelyTraverseAtomicPassiveEffects(
           flags & 2048 &&
             commitOffscreenPassiveMountEffects(
               finishedWork.alternate,
-              finishedWork
+              finishedWork,
+              finishedWork.stateNode
             );
           break;
         case 24:
@@ -11530,10 +12761,11 @@ function recursivelyTraverseDisconnectPassiveEffects(parentFiber) {
 }
 function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
   deletedSubtreeRoot,
-  nearestMountedAncestor
+  nearestMountedAncestor$jscomp$0
 ) {
   for (; null !== nextEffect; ) {
-    var fiber = nextEffect;
+    var fiber = nextEffect,
+      nearestMountedAncestor = nearestMountedAncestor$jscomp$0;
     switch (fiber.tag) {
       case 0:
       case 11:
@@ -11542,35 +12774,87 @@ function commitPassiveUnmountEffectsInsideOfDeletedTree_begin(
         break;
       case 23:
       case 22:
-        if (
-          null !== fiber.memoizedState &&
-          null !== fiber.memoizedState.cachePool
-        ) {
-          var cache = fiber.memoizedState.cachePool.pool;
-          null != cache && cache.refCount++;
+        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
+              )));
     }
-    cache = fiber.child;
-    if (null !== cache) (cache.return = fiber), (nextEffect = cache);
+    nearestMountedAncestor = fiber.child;
+    if (null !== nearestMountedAncestor)
+      (nearestMountedAncestor.return = fiber),
+        (nextEffect = nearestMountedAncestor);
     else
       a: for (fiber = deletedSubtreeRoot; null !== nextEffect; ) {
-        cache = nextEffect;
-        var sibling = cache.sibling,
-          returnFiber = cache.return;
-        detachFiberAfterEffects(cache);
-        if (cache === fiber) {
+        nearestMountedAncestor = nextEffect;
+        offscreenFiber = nearestMountedAncestor.sibling;
+        instance = nearestMountedAncestor.return;
+        detachFiberAfterEffects(nearestMountedAncestor);
+        if (nearestMountedAncestor === fiber) {
           nextEffect = null;
           break a;
         }
-        if (null !== sibling) {
-          sibling.return = returnFiber;
-          nextEffect = sibling;
+        if (null !== offscreenFiber) {
+          offscreenFiber.return = instance;
+          nextEffect = offscreenFiber;
           break a;
         }
-        nextEffect = returnFiber;
+        nextEffect = instance;
       }
   }
 }
@@ -11773,6 +13057,18 @@ function findAllNodes(hostRoot, selectors) {
   }
   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,
@@ -11796,7 +13092,70 @@ var ceil = Math.ceil,
   workInProgressRootRecoverableErrors = null,
   globalMostRecentFallbackTime = 0,
   workInProgressRootRenderTargetTime = Infinity,
-  workInProgressTransitions = null;
+  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;
 }
@@ -11821,7 +13180,11 @@ function requestEventTime() {
 }
 function requestUpdateLane(fiber) {
   if (0 === (fiber.mode & 1)) return 2;
-  if (0 !== (executionContext & 2) && 0 !== workInProgressRootRenderLanes)
+  if (
+    !deferRenderPhaseUpdateToNextBatch &&
+    0 !== (executionContext & 2) &&
+    0 !== workInProgressRootRenderLanes
+  )
     return workInProgressRootRenderLanes & -workInProgressRootRenderLanes;
   if (null !== ReactCurrentBatchConfig$1.transition)
     return (
@@ -11841,18 +13204,35 @@ function scheduleUpdateOnFiber(root, fiber, lane, eventTime) {
     (prepareFreshStack(root, 0),
     markRootSuspended(root, workInProgressRootRenderLanes));
   markRootUpdated(root, lane, eventTime);
-  if (0 === (executionContext & 2) || root !== workInProgressRoot)
-    root === workInProgressRoot &&
-      (0 === (executionContext & 2) &&
-        (workInProgressRootInterleavedUpdatedLanes |= lane),
+  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());
+        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;
@@ -11921,7 +13301,7 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
   didTimeout =
     includesBlockingLane(root, lanes) ||
     0 !== (lanes & root.expiredLanes) ||
-    didTimeout
+    (!disableSchedulerTimeoutInWorkLoop && didTimeout)
       ? renderRootSync(root, lanes)
       : renderRootConcurrent(root, lanes);
   if (0 !== didTimeout) {
@@ -11958,16 +13338,16 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
         didTimeout = renderRootSync(root, lanes);
         if (2 === didTimeout) {
           errorRetryLanes = lanes;
-          var errorRetryLanes$190 = getLanesToRetrySynchronouslyOnError(
+          var errorRetryLanes$213 = getLanesToRetrySynchronouslyOnError(
             root,
             errorRetryLanes
           );
-          0 !== errorRetryLanes$190 &&
-            ((lanes = errorRetryLanes$190),
+          0 !== errorRetryLanes$213 &&
+            ((lanes = errorRetryLanes$213),
             (didTimeout = recoverFromConcurrentError(
               root,
               errorRetryLanes,
-              errorRetryLanes$190
+              errorRetryLanes$213
             )));
         }
         if (1 === didTimeout)
@@ -12021,11 +13401,11 @@ function performConcurrentWorkOnRoot(root, didTimeout) {
           if ((lanes & 8388480) === lanes) break;
           didTimeout = root.eventTimes;
           for (originallyAttemptedLanes = -1; 0 < lanes; )
-            (errorRetryLanes$190 = 31 - clz32(lanes)),
-              (errorRetryLanes = 1 << errorRetryLanes$190),
-              (errorRetryLanes$190 = didTimeout[errorRetryLanes$190]),
-              errorRetryLanes$190 > originallyAttemptedLanes &&
-                (originallyAttemptedLanes = errorRetryLanes$190),
+            (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;
@@ -12341,7 +13721,8 @@ function renderRootSync(root, lanes) {
   var prevDispatcher = pushDispatcher(root.containerInfo),
     prevCacheDispatcher = pushCacheDispatcher();
   if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
-    (workInProgressTransitions = null), prepareFreshStack(root, lanes);
+    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
+      prepareFreshStack(root, lanes);
   a: do
     try {
       if (0 !== workInProgressSuspendedReason && null !== workInProgress) {
@@ -12360,8 +13741,8 @@ function renderRootSync(root, lanes) {
       }
       workLoopSync();
       break;
-    } catch (thrownValue$193) {
-      handleThrow(root, thrownValue$193);
+    } catch (thrownValue$216) {
+      handleThrow(root, thrownValue$216);
     }
   while (1);
   resetContextDependencies();
@@ -12385,7 +13766,7 @@ function renderRootConcurrent(root, lanes) {
   var prevDispatcher = pushDispatcher(root.containerInfo),
     prevCacheDispatcher = pushCacheDispatcher();
   if (workInProgressRoot !== root || workInProgressRootRenderLanes !== lanes)
-    (workInProgressTransitions = null),
+    (workInProgressTransitions = getTransitionsForLanes(root, lanes)),
       resetRenderTimer(),
       prepareFreshStack(root, lanes);
   a: do
@@ -12441,8 +13822,8 @@ function renderRootConcurrent(root, lanes) {
       }
       workLoopConcurrent();
       break;
-    } catch (thrownValue$195) {
-      handleThrow(root, thrownValue$195);
+    } catch (thrownValue$218) {
+      handleThrow(root, thrownValue$218);
     }
   while (1);
   resetContextDependencies();
@@ -12531,8 +13912,18 @@ function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
           "object" === typeof value &&
           "function" === typeof value.then
         ) {
-          var wakeable = value,
-            tag = unitOfWork.tag;
+          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)
@@ -12580,10 +13971,10 @@ function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
                     };
                     suspenseBoundary.updateQueue = newOffscreenQueue;
                   } else {
-                    var wakeables$95 = offscreenQueue.wakeables;
-                    null === wakeables$95
+                    var wakeables$100 = offscreenQueue.wakeables;
+                    null === wakeables$100
                       ? (offscreenQueue.wakeables = new Set([wakeable]))
-                      : wakeables$95.add(wakeable);
+                      : wakeables$100.add(wakeable);
                   }
                   break;
                 }
@@ -12632,7 +14023,7 @@ function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
               enqueueCapturedUpdate(root, update);
               break a;
             case 1:
-              tag = value;
+              currentSourceFiber = value;
               var ctor = root.type,
                 instance = root.stateNode;
               if (
@@ -12646,7 +14037,11 @@ function unwindSuspendedUnitOfWork(unitOfWork, thrownValue) {
                 root.flags |= 65536;
                 update = thrownValue & -thrownValue;
                 root.lanes |= update;
-                errorInfo = createClassErrorUpdate(root, tag, update);
+                errorInfo = createClassErrorUpdate(
+                  root,
+                  currentSourceFiber,
+                  update
+                );
                 enqueueCapturedUpdate(root, errorInfo);
                 break a;
               }
@@ -12759,12 +14154,12 @@ function commitRootImpl(
     var prevExecutionContext = executionContext;
     executionContext |= 4;
     ReactCurrentOwner.current = null;
-    var shouldFireAfterActiveInstanceBlur$198 = commitBeforeMutationEffects(
+    var shouldFireAfterActiveInstanceBlur$221 = commitBeforeMutationEffects(
       root,
       finishedWork
     );
     commitMutationEffectsOnFiber(finishedWork, root);
-    shouldFireAfterActiveInstanceBlur$198 &&
+    shouldFireAfterActiveInstanceBlur$221 &&
       ((_enabled = !0),
       dispatchAfterDetachedBlur(selectionInformation.focusedElem),
       (_enabled = !1));
@@ -12816,6 +14211,23 @@ function commitRootImpl(
       : ((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) {
@@ -12826,51 +14238,64 @@ function releaseRootPooledCache(root, remainingLanes) {
 }
 function flushPassiveEffects() {
   if (null !== rootWithPendingPassiveEffects) {
-    var root$199 = rootWithPendingPassiveEffects,
+    var root$222 = rootWithPendingPassiveEffects,
       remainingLanes = pendingPassiveEffectsRemainingLanes;
     pendingPassiveEffectsRemainingLanes = 0;
-    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes),
-      priority = 32 > renderPriority ? 32 : renderPriority;
-    renderPriority = ReactCurrentBatchConfig.transition;
-    var previousPriority = currentUpdatePriority;
+    var renderPriority = lanesToEventPriority(pendingPassiveEffectsLanes);
+    renderPriority = 32 > renderPriority ? 32 : renderPriority;
+    var prevTransition = ReactCurrentBatchConfig.transition,
+      previousPriority = currentUpdatePriority;
     try {
-      ReactCurrentBatchConfig.transition = null;
-      currentUpdatePriority = priority;
-      if (null === rootWithPendingPassiveEffects)
-        var JSCompiler_inline_result = !1;
-      else {
-        priority = 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, priority);
-        executionContext = prevExecutionContext;
-        flushSyncCallbacks();
-        if (
-          injectedHook &&
-          "function" === typeof injectedHook.onPostCommitFiberRoot
-        )
-          try {
-            injectedHook.onPostCommitFiberRoot(rendererID, root);
-          } catch (err) {}
-        JSCompiler_inline_result = !0;
-      }
-      return JSCompiler_inline_result;
+      return (
+        (ReactCurrentBatchConfig.transition = null),
+        (currentUpdatePriority = renderPriority),
+        flushPassiveEffectsImpl()
+      );
     } finally {
       (currentUpdatePriority = previousPriority),
-        (ReactCurrentBatchConfig.transition = renderPriority),
-        releaseRootPooledCache(root$199, remainingLanes);
+        (ReactCurrentBatchConfig.transition = prevTransition),
+        releaseRootPooledCache(root$222, remainingLanes);
     }
   }
   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;
+}
 function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
   sourceFiber = createCapturedValueAtFiber(error, sourceFiber);
   sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 2);
@@ -12884,7 +14309,13 @@ function captureCommitPhaseError(sourceFiber, nearestMountedAncestor, error) {
   if (3 === sourceFiber.tag)
     captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
   else
-    for (; null !== nearestMountedAncestor; ) {
+    for (
+      nearestMountedAncestor = skipUnmountedBoundaries
+        ? nearestMountedAncestor
+        : sourceFiber.return;
+      null !== nearestMountedAncestor;
+
+    ) {
       if (3 === nearestMountedAncestor.tag) {
         captureCommitPhaseErrorOnRoot(
           nearestMountedAncestor,
@@ -13000,7 +14431,7 @@ beginWork = function (current, workInProgress, renderLanes) {
       didReceiveUpdate = !0;
     else {
       if (
-        0 === (current.lanes & renderLanes) &&
+        !checkScheduledUpdateOrContext(current, renderLanes) &&
         0 === (workInProgress.flags & 128)
       )
         return (
@@ -13137,6 +14568,9 @@ beginWork = function (current, workInProgress, renderLanes) {
         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 &&
@@ -13429,7 +14863,7 @@ beginWork = function (current, workInProgress, renderLanes) {
         prevState = workInProgress.memoizedProps;
         root = init.value;
         pushProvider(workInProgress, Component, root);
-        if (null !== prevState)
+        if (!enableLazyContextPropagation && null !== prevState)
           if (objectIs(prevState.value, root)) {
             if (prevState.children === init.children) {
               workInProgress = bailoutOnAlreadyFinishedWork(
@@ -13512,6 +14946,8 @@ beginWork = function (current, workInProgress, renderLanes) {
       );
     case 22:
       return updateOffscreenComponent(current, workInProgress, renderLanes);
+    case 23:
+      return updateOffscreenComponent(current, workInProgress, renderLanes);
     case 24:
       return (
         prepareToReadContext(workInProgress, renderLanes),
@@ -13557,6 +14993,37 @@ beginWork = function (current, workInProgress, 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));
 };
@@ -13727,13 +15194,14 @@ function createFiberFromTypeAndProps(
       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 (
-          (key = createFiber(21, pendingProps, key, mode)),
-          (key.type = type),
-          (key.elementType = type),
-          (key.lanes = lanes),
-          key
+          (pendingProps = createFiber(21, pendingProps, key, mode)),
+          (pendingProps.type = type),
+          (pendingProps.elementType = type),
+          (pendingProps.lanes = lanes),
+          pendingProps
         );
       case REACT_CACHE_TYPE:
         return (
@@ -13742,6 +15210,27 @@ function createFiberFromTypeAndProps(
           (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) {
@@ -13766,11 +15255,11 @@ function createFiberFromTypeAndProps(
           formatProdErrorMessage(130, null == type ? type : typeof type, "")
         );
     }
-  key = createFiber(fiberTag, pendingProps, key, mode);
-  key.elementType = type;
-  key.type = owner;
-  key.lanes = lanes;
-  return key;
+  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);
@@ -13789,29 +15278,36 @@ function createFiberFromOffscreen(pendingProps, mode, lanes, key) {
     _transitions: null,
     _current: null,
     detach: function () {
-      var fiber = primaryChildInstance._current;
-      if (null === fiber) throw Error(formatProdErrorMessage(456));
-      if (0 === (primaryChildInstance._pendingVisibility & 2)) {
-        var root = enqueueConcurrentRenderForLane(fiber, 2);
-        null !== root &&
-          ((primaryChildInstance._pendingVisibility |= 2),
-          scheduleUpdateOnFiber(root, fiber, 2, -1));
-      }
+      return detachOffscreenInstance(primaryChildInstance);
     },
     attach: function () {
-      var fiber = primaryChildInstance._current;
-      if (null === fiber) throw Error(formatProdErrorMessage(456));
-      if (0 !== (primaryChildInstance._pendingVisibility & 2)) {
-        var root = enqueueConcurrentRenderForLane(fiber, 2);
-        null !== root &&
-          ((primaryChildInstance._pendingVisibility &= -3),
-          scheduleUpdateOnFiber(root, fiber, 2, -1));
-      }
+      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;
@@ -13868,6 +15364,15 @@ function FiberRootNode(
   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,
@@ -13878,7 +15383,8 @@ function createFiberRoot(
   isStrictMode,
   concurrentUpdatesByDefaultOverride,
   identifierPrefix,
-  onRecoverableError
+  onRecoverableError,
+  transitionCallbacks
 ) {
   containerInfo = new FiberRootNode(
     containerInfo,
@@ -13888,6 +15394,8 @@ function createFiberRoot(
     onRecoverableError
   );
   containerInfo.hydrationCallbacks = hydrationCallbacks;
+  enableTransitionTracing &&
+    (containerInfo.transitionCallbacks = transitionCallbacks);
   1 === tag
     ? ((tag = 1),
       !0 === isStrictMode && (tag |= 24),
@@ -13999,7 +15507,11 @@ ReactDOMHydrationRoot.prototype.unstable_scheduleHydration = function (target) {
 function isValidContainer(node) {
   return !(
     !node ||
-    (1 !== node.nodeType && 9 !== node.nodeType && 11 !== node.nodeType)
+    (1 !== node.nodeType &&
+      9 !== node.nodeType &&
+      11 !== node.nodeType &&
+      (8 !== node.nodeType ||
+        " react-mount-point-unstable " !== node.nodeValue))
   );
 }
 function registerReactDOMEvent(target, domEventName, isCapturePhaseListener) {
@@ -14026,12 +15538,12 @@ function registerReactDOMEvent(target, domEventName, isCapturePhaseListener) {
 _attemptSynchronousHydration = function (fiber) {
   switch (fiber.tag) {
     case 3:
-      var root$201 = fiber.stateNode;
-      if (root$201.current.memoizedState.isDehydrated) {
-        var lanes = getHighestPriorityLanes(root$201.pendingLanes);
+      var root$224 = fiber.stateNode;
+      if (root$224.current.memoizedState.isDehydrated) {
+        var lanes = getHighestPriorityLanes(root$224.pendingLanes);
         0 !== lanes &&
-          (markRootEntangled(root$201, lanes | 2),
-          ensureRootIsScheduled(root$201, now()),
+          (markRootEntangled(root$224, lanes | 2),
+          ensureRootIsScheduled(root$224, now()),
           0 === (executionContext & 6) &&
             (resetRenderTimer(), flushSyncCallbacks()));
       }
@@ -14047,6 +15559,16 @@ _attemptSynchronousHydration = function (fiber) {
         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);
@@ -14111,17 +15633,17 @@ Internals.Events = [
   restoreStateIfNeeded,
   batchedUpdates
 ];
-var devToolsConfig$jscomp$inline_1672 = {
+var devToolsConfig$jscomp$inline_1749 = {
   findFiberByHostInstance: getClosestInstanceFromNode,
   bundleType: 0,
-  version: "18.3.0-www-modern-f236d170",
+  version: "18.3.0-www-modern-724bb919",
   rendererPackageName: "react-dom"
 };
-var internals$jscomp$inline_2080 = {
-  bundleType: devToolsConfig$jscomp$inline_1672.bundleType,
-  version: devToolsConfig$jscomp$inline_1672.version,
-  rendererPackageName: devToolsConfig$jscomp$inline_1672.rendererPackageName,
-  rendererConfig: devToolsConfig$jscomp$inline_1672.rendererConfig,
+var internals$jscomp$inline_2154 = {
+  bundleType: devToolsConfig$jscomp$inline_1749.bundleType,
+  version: devToolsConfig$jscomp$inline_1749.version,
+  rendererPackageName: devToolsConfig$jscomp$inline_1749.rendererPackageName,
+  rendererConfig: devToolsConfig$jscomp$inline_1749.rendererConfig,
   overrideHookState: null,
   overrideHookStateDeletePath: null,
   overrideHookStateRenamePath: null,
@@ -14138,26 +15660,26 @@ var internals$jscomp$inline_2080 = {
     return null === fiber ? null : fiber.stateNode;
   },
   findFiberByHostInstance:
-    devToolsConfig$jscomp$inline_1672.findFiberByHostInstance ||
+    devToolsConfig$jscomp$inline_1749.findFiberByHostInstance ||
     emptyFindFiberByHostInstance,
   findHostInstancesForRefresh: null,
   scheduleRefresh: null,
   scheduleRoot: null,
   setRefreshHandler: null,
   getCurrentFiber: null,
-  reconcilerVersion: "18.3.0-www-modern-f236d170"
+  reconcilerVersion: "18.3.0-www-modern-724bb919"
 };
 if ("undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) {
-  var hook$jscomp$inline_2081 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+  var hook$jscomp$inline_2155 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
   if (
-    !hook$jscomp$inline_2081.isDisabled &&
-    hook$jscomp$inline_2081.supportsFiber
+    !hook$jscomp$inline_2155.isDisabled &&
+    hook$jscomp$inline_2155.supportsFiber
   )
     try {
-      (rendererID = hook$jscomp$inline_2081.inject(
-        internals$jscomp$inline_2080
+      (rendererID = hook$jscomp$inline_2155.inject(
+        internals$jscomp$inline_2154
       )),
-        (injectedHook = hook$jscomp$inline_2081);
+        (injectedHook = hook$jscomp$inline_2155);
     } catch (err) {}
 }
 exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Internals;
@@ -14181,7 +15703,8 @@ exports.createRoot = function (container, options) {
   var isStrictMode = !1,
     concurrentUpdatesByDefaultOverride = !1,
     identifierPrefix = "",
-    onRecoverableError = defaultOnRecoverableError;
+    onRecoverableError = defaultOnRecoverableError,
+    transitionCallbacks = null;
   null !== options &&
     void 0 !== options &&
     (!0 === options.unstable_strictMode && (isStrictMode = !0),
@@ -14190,7 +15713,9 @@ exports.createRoot = function (container, options) {
     void 0 !== options.identifierPrefix &&
       (identifierPrefix = options.identifierPrefix),
     void 0 !== options.onRecoverableError &&
-      (onRecoverableError = options.onRecoverableError));
+      (onRecoverableError = options.onRecoverableError),
+    void 0 !== options.unstable_transitionCallbacks &&
+      (transitionCallbacks = options.unstable_transitionCallbacks));
   options = createFiberRoot(
     container,
     1,
@@ -14200,7 +15725,8 @@ exports.createRoot = function (container, options) {
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   );
   container[internalContainerInstanceKey] = options.current;
   Dispatcher.current = ReactDOMClientDispatcher;
@@ -14342,7 +15868,8 @@ exports.hydrateRoot = function (container, initialChildren, options) {
     isStrictMode = !1,
     concurrentUpdatesByDefaultOverride = !1,
     identifierPrefix = "",
-    onRecoverableError = defaultOnRecoverableError;
+    onRecoverableError = defaultOnRecoverableError,
+    transitionCallbacks = null;
   null !== options &&
     void 0 !== options &&
     (!0 === options.unstable_strictMode && (isStrictMode = !0),
@@ -14351,7 +15878,9 @@ exports.hydrateRoot = function (container, initialChildren, options) {
     void 0 !== options.identifierPrefix &&
       (identifierPrefix = options.identifierPrefix),
     void 0 !== options.onRecoverableError &&
-      (onRecoverableError = options.onRecoverableError));
+      (onRecoverableError = options.onRecoverableError),
+    void 0 !== options.unstable_transitionCallbacks &&
+      (transitionCallbacks = options.unstable_transitionCallbacks));
   initialChildren = createFiberRoot(
     container,
     1,
@@ -14361,7 +15890,8 @@ exports.hydrateRoot = function (container, initialChildren, options) {
     isStrictMode,
     concurrentUpdatesByDefaultOverride,
     identifierPrefix,
-    onRecoverableError
+    onRecoverableError,
+    transitionCallbacks
   );
   initialChildren.context = emptyContextObject;
   options = initialChildren.current;
@@ -14473,4 +16003,4 @@ exports.unstable_flushControlled = function (fn) {
   }
 };
 exports.unstable_runWithPriority = runWithPriority;
-exports.version = "18.3.0-www-modern-f236d170";
+exports.version = "18.3.0-www-modern-724bb919";
diff --git a/compiled/facebook-www/ReactTestRenderer-dev.modern.js b/compiled/facebook-www/ReactTestRenderer-dev.modern.js
index da9c8f2122427..0cd9c8734a19d 100644
--- a/compiled/facebook-www/ReactTestRenderer-dev.modern.js
+++ b/compiled/facebook-www/ReactTestRenderer-dev.modern.js
@@ -23954,7 +23954,7 @@ function createFiberRoot(
   return root;
 }
 
-var ReactVersion = "18.3.0-www-modern-f236d170";
+var ReactVersion = "18.3.0-www-modern-724bb919";
 
 // Might add PROFILE later.